Ubuntu Linux auf dem Acer 5630Z mit WLAN

Ich habe mir ein Notebook Acer 5630Z gekauft. Ein schönes Notebook, das im T-Online-Shop ohne Betriebsystem angeboten wird. Ich konnte Kubuntu 8.04 ohne Probleme installieren. Leider habe ich es nicht geschafft,  das WLAN ans Laufen zu bekommen.

Daraufhin habe ich Ubuntu 8.10 installiert. Es lief ebenfalls auf Anhieb. Um das WLAN ans Laufen zu bringen, reicht es, diesen Treiber zu installieren. Dabei muss der Rechner eine Kabelverbindung ins Internet haben, da der Paketmanager weitere Pakete installieren will. Danach muss der Rechner neu gebootet werden. Dann arbeitet auch das WLAN.

Ob das auch unter Kubuntu 8.10 funktioniert, weiss ich nicht. Ich nehme aber an, daß es ebenfalls Problemlos arbeitet ich habe es nicht ausprobiert.

Tags: 5630Z Linux WLAN

Abstraktion einer Funktion nach sich selbst: Der Y-Kombinator

print sub{$_[0]*3}->(8);

sub mal3 {$_[0]*3}

*mal3 = sub{$_[0]*3};

*fak =
   sub {
     my $n=shift;
     if ($n==0) {
       return 1
     }
     else {
        return $n * fak($n -1);
     }
   };

*pfak =
  sub {
     my $psi=shift;
     return sub {
       my $n=shift;
       if ($n==0) {
         return 1
       }
       else {
          return $n * $psi->($n -1);
       }
     }
  };

*fak = pfak(\&fak)

hurz === pfak(\&hurz)

hurz === Y(\&pfak)

   sub Y {
       my $e=shift;
       sub {
         my $x=shift;
         sub {
           my $u=shift;
           ($e->($x->($x)))->($u)
         }
       }->(sub {
             my $x=shift;
             sub {
               my $u=shift;
               ($e->($x->($x)))->($u)
             }
           }
         )
       }

print Y(\&pfak)->(10)

fak == Y(\&pfak)

Y(\&efak) ===

sub {
  my $x=shift;
  sub {
    my $u=shift;
    (pfak($x->($x)))->($u)
  }
}->(sub {
      my $x=shift;
      sub {
        my $u=shift;
        (pfak($x->($x)))->($u)
      }
    }
)

$A = sub {
       my $x=shift;
       sub {
         my $u=shift;
         (pfak($x->($x)))->($u)
       }
    };

$A->($A)===sub {
             my $u=shift;
             (pfak($A->($A)))->($u)
           }

Y(\&pfak) === sub {
                $u=shift;
                (pfak(Y(\&pfak))->($u)
              }

Y(\&pfak)->($N) === pfak(Y(\&pfak))->($N)

Scannen mit Perl (Lexer)

Scanner

Mit Perl einen Scanner zu schreiben, ist eine einfache Sache, denn Perl hat eine sehr potente Implementierung für reguläre Ausdrücke. Allerdings muss man wissen, welche Modifier erforderlich sind, damit der Lexer auch immer an der Stelle weitermacht, wo er aufgehört hat. Dazu benutzt man den Pattern Matcher mit dem Modifier /g und startet jedes Matching mit dem Anker \G. Durch /g wird erreicht, daß Perl sich die aktuelle Scanposition merkt und mit \G verlangen wir, das bei der nächsten Mustererkennung genau an dieser Stelle weitergemacht werden soll.

Zusätzlich muss der Modifier /c angegeben werden, damit Perl die Position auch dann behält, wenn ein matching-Versuch scheitert und deswegen ein anderes Pattern versucht werden soll (was der häufigste Fall sein wird). Die weiteren Modifier, die verwendet werden sind /s , damit der Scanner mit einem Text umgeht, als wäre es eine einzelne Zeile und manchmal /i, damit “case-insensitiv” gescannt wird.

Von einem Lexer erwarten wir, daß er einen String in Tokens zerlegt und bei jedem Aufruf das nächste erkannte Token zurückgibt. Außerdem brauchen wir von jedem Token das gescannte Lexem. Bei jedem Aufruf bekommen wir also zwei Werte. Wird zum beispiel des Schlüsselwort “select” erkannt, bekommen wir das Wertepaar ['KEYW' , 'select'] geliefert.

Hier also die Implemetierung eines Fragmentes eines SQL-Scanners Das Lexen übernimmt die sub lex. Darunter eine Schleife, die die Ergebnisse ausgibt.

use strict;
$_ = <<EOT;
select name,alter 
        FROM person 
        where name like \'Kaz%mir\' and alter>20;
EOT

sub lex {
  /\G(\s+)/gcs;         # spaces wegfuttern.
  return [$1,'OP'] if /\G"([\*\+\-\/]*)"/gcs;
  return [uc($1),'KEYW'] if /\G(from|like|select|where)/gcsi;
  return [$1,'COMM'] if /\G(\,)/gcs;
  return [$1,'SEMI'] if /\G(\;)/gcs;
  return [$1,'COMP'] if /\G(>|<|>=|<=|=)/gcs;
  return [$1,'STRI'] if /\G'([^']*)'/gcs;
  return [$1,'IDEN'] if /\G([a-zA-Z_]+)/gcs;
  return [$1,'INTE'] if /\G(\d+)/gcs;
  return undef if /\G$/;
  die "lexer error at '",substr(substr($_,pos($_)),0,60),"'";
}

while (my $t = lex) {
  print "$t->[1] '$t->[0]' ",pos(),"\n";
}

Das hier vorgestellte Vorgehen ist einfach zu überblicken und der Scanner arbeitet schnell. Wie man einen einfachen Recursive-Descent-Parser dazu baut, werde ich eventuell ebenfalls einmal hier notieren.

Tags: Flex, Lexer, Perl, Scanner

Faltungen

Datenbanken kennen Aggregatfunktionen. Ein Aggregat ist - Ja? - leider daneben! Ein Aggregat ist eine Anhäufung. Im Grunde ist die ehrfurchtsgebietende Miene, mit der ein Heizungsfachman ein elektronisches Kästchen aus einer Packung holt, während er dieses als Aggregat bezeichnet um es darauf in die kaputte Heizung einzubauen, eher lachhaft. Würde er sagen, er baue jetzt einen elektronischen Haufen in die Heizung ein, würden wir eher grinsen als ehrfürchtig Abstand haltend sein fachmännisches Tun zu würdigen.

Mit Aggregat ist also gemeint, dass wir etwas unübersichtiches zu einem Haufen zusammenwerfen, um den Überblick zu behalten. Etwas vornehmer nennt man diesen Vorgang manchmal auch Faltung.

Beispiele bei Datenbanken sind zum Beispiel COUNT(*) für die Anzahl der Elemente, AVG(*) für deren Durchschnitt und SUM(*) die Summe aller Elemente.

Was mich immer schon geärgert hat ist, ist, das zumindest bei Datenbankten kein offensichtlicher Weg existiert, solche “Aggregatfunktionen” selber zu definieren. Mag sein, daß einzelne dieser Datenbanken solche Möglichkeiten haben. In der SQL’92 Spezifikation sind Aggregatfunktionen vorgegbene schwarze Kisten, die man benutzen kann. Sonst nichts.

Das Wesen einer Aggregatfunktion oder Faltung ist, eine Liste “zusammenzufalten”, sodaß man Ende der Operation ein einzelnes etwas (etwa eine Summe) anstatt einer unhandlichen Liste hat.

Wie kommt man zu einer Aggregatfunkion? Aus der Operation z(a,b)=a+b gelang man zu der Aggregatfunktion SUM(*)  aus der Operation z(n,a)=n+1 gelangt man zu Aggregatfunktion COUNT(*) und anderes mehr. Jeder Programmieranfänger hat schonmal eine Aggregation programmiert, ohne sich darüber Gedanken gemacht zu haben. Dazu ist der Vorgang auch insgesamt zu banal. Zumeist wird man wohl eine FOR-Schleife verwendet haben. Das ist sehr schön. aber nicht unser Thema. gesucht ist eine Generalisierung dieses Vorgangs. Das bedeutet, daß wir die gesamte Faltung von dem konkreten Faltungsoperator abstrahieren müssen.

Angenommen, wir haben eine Liste L=(x1,x2,..xn) sowie eine zweistellige Faltungsoperation z. Dann ist die Faltung f eine Funktion höherer Ordnung mit dem Faltungsoperator z und der Liste L als Argumenten:

f(z,L) = z( L[0] , L[1] )           falls die Liste zweielementig ist und
z( L[0] , f(z, L[1..n])              sonst

Beispiel:

z(a,b)=a+b und L=[4,3,2,6]

Dann ist

f(z,L)=
4+f(z,[3,2,6])=
4+3+f(z,[2,6])=
4+3+2+6=15.

Schönheitsfehler ist noch, daß unsere Konstruktion nur mit mindestens zweielementigen Listen arbeitet. Dem kann man mit einem zusätzlichen Startparameter s begegnen, mit dem das erste Listenelement verknüpft wird.

Dann kommt man zu folgender Version:

f(s,z,L) = s    falls die Liste leer ist,
z( L[0] , f(s,z, L[1..n])    sonst.

In Perl kann das so aussehen:

sub foldleft ($&@) {
  my ($s,$z,@l)=@_;
  return $s unless @l;
  my $a = shift @l;
  return $z->($a,foldleft($s,$z,@l));
}

Schöner und schneller ist aber diese iterative Version:

sub foldl ($&@) {
  my ($s,$z,@l) = @_;
  $s = $z->($s,$_) for (@l);
  return $s
}

Wozu das gut ist? Ganz einfach: Durch Konstruktionen wie diese spart man innere Schleifen. Um nun die Summe aller Elemente einer Liste zu bilden, kann man

$summe = foldl 0, sub {$_[0]+$_[1]}, @LISTE

schreiben.

Um alle Zeilen einer Datei zusammenzufassen und dabei zwischen je zwei Zeilen eine Leerzeile einzubauen:

$text =  foldl 0, sub {$_[0] . "\n". $_[1]}, <FILE>;

Anstatt hier fehleranfällig mit Schleifen und Variablen zu arbeiten, kann man eine einzige Funktion aufrufen. Funktionale Programmiersprachen wie Haskell und andere haben eine solche Faltungsfunktion direkt mit eingebaut. Interessant ist auch, daß große Teile der Programmentwicklung sich gerade mit Aggregationen befassen, auch wenn uns das nicht immer bewusst ist. Wer als Programmierer ein bisschen darüber nachdenkt, was er gerade tut, stößt täglich selbst auf Beispiele. Jeder Erstellung einer HTML-Seite aus einer Datenbankabfrage ist  ein solches Beispiel.

Tags: Aggregation, Faltung, Fold, Perl

XML als Objekte parsen

Für ein aktuelles Projekt benötge ich einen Parsebaum aus XML-Dokumenten, der aus Objekten besteht. Ich bin sicher, daß schon mal so oder ähnlich jemand gemacht hat. Leider ist CPAN mittlerweile recht groß…

Meine Vorstellung ist, daß der Tagname der Klassenname des Objektes wird. Zu diesem Zweck muss der etwas gewöhnungsbedürftige Output von XML::Parser transformiert werden. Die Objekte sollen Hashes sein mit den Einträgen “attr” und “data”. “attr” soll seinerseits ein hash der Attributwerte sein und data ein array mit den Sub-Objekten.

Los gehts:

package main;
use XML::Parser;
use Data::Dumper;
my $p = new XML::Parser(Style => 'Tree');
my $t= $p->parse('<html htmlattr1="xx">
<head headattr1="a" headattr2="b"><title>test</title></head>
<body>
<div style="color:red">murx</div>
</body>
</html>'); 

print Dumper($t);

sub transform {
  my ($tag,$content) = @_;
  return $content unless $tag;
  my @content = @$content; #kopie!
  my $attr = shift @content;
  my %attr = %$attr; #kopie!
  # an dieser stelle haben wir mit $tag, %attr und @content eine
  # repräsentation des aktuellen tags

  my @tags;
  while (@content) {
    my $t = shift @content;
    my $c = shift @content;
    push @tags, transform($t,$c);
  }
  my $obj={
	   attr => \%attr,
	   data => \@tags,
	  };
  return bless $obj,$tag;
}

my $objtree = transform(@$t->[0], $t->[1]);
print Dumper($objtree);

Tags: parsing, Perl, XML

Backup mit sftp / sshfs von einer billigen Präsenz

Tags: 1und1, backup, sftp, ssh, sshfs

Perl Attribute

Lisp wurde schon einmal als programmierbare Programiersprache bezeichnet. In engeren Genzen trifft dies auch auf Perl zu.

Es gibt in Perl ein Feature namens “Attributes”, das selten verwendet wird. Dieses Feature habe ich für ein Mini-Framework eingesetzt. In diesem Framework wollte ich erreichen, daß bestimmte, von mir mit “Session” Attributierte Variablen in der Session gespeichert werden, sodaß sie beim nächsten Request unverändert zur Verfügung stehen. Dadurch will ich erreichen, daß ich Werte nicht mehr explizit durch $name = $session->param(’name’) und Anderem, wie $session->flush() einlesen und speichern muss.

Im Anwendungscode sieht das zum Beispiel so aus:

my $name : Session('Name') ;

mit dieser Deklaration will ich dem System mitteilen, daß ich erwarte, daß diese Variable aus der Session geholt wird und am Ende der Bearbeitung des Requests wieder dort abgelegt wird.

Um dies zu erreichen, liegt im Framework eine sub MODIFY_SCALAR_ATTRIBUTE vor. Perl ruft diese Routine auf, sobald eine Variable mit einem Attribut (das ist hier der String “Session(Name)” ) versehen ist. Den Code der das Handling der Session vornimmt, stelle ich hier nicht vor, sondern nur die Routine, die die Attribut-Behandlung vornimmt.

my @SESSION_VARS;

sub MODIFY_SCALAR_ATTRIBUTES {
  my ($mod, $ref, $attr) = @_;
  my ($name) = $attr =~ /\((.*)\)/;
  push @SESSION_VARS, {$name => $ref} ;
  return ();
}

An MODIFY_SCALAR_ATTRIBUTES übergibt perl im Moment der Einrichtung der Variablen den Modulnamen, die Referenz auf die Variable und das Attribut.

Die Beispiel-Sub sammelt die Namen der Session-Variablen alle zusammen, um sie später unter Anwendung einer sub END { } geeignet zu behandeln.

Auf diese Weise kann ich Session-Werte so behandeln, als gehörten Sie in einen Übergeordneten Namensraum um den ich mich nicht kümmern muss.

Ausführlicheres zum Thema findet man unter Linux mit “man attributes”

Tags: Attribute, Perl

Genesis in Lisp

Gefunden bei http:://xkcd.com :

CPAN SearchPlugin für Mozilla

Folgendes Plugin ermöglicht die Suche im CPAN mit Mozilla. Um es zu aktivierten, muss die Datei unter $HOME/.mozilla/firefox/xxxxxxxx.default/searchplugins abgelegt werden.
Unter windows ist C:\Eigene Dateien\Mozilla firefox\Searchplugins der richtige Ort

<OpenSearchDescription xmlns="http://a9.com/-/spec/opensearch/1.1/"
                       xmlns:moz="http://www.mozilla.org/2006/browser/search/">
<ShortName>CPAN Search
<Description>search for CPAN modules
<InputEncoding>iso-8859-1
<Image width="16" height="16"> data:image/x-icon;base64,AAABAAEAEBAAAAAAAAAoAQAAFgAAACgAAAAQAAAAIAAAAAEABAAAAAAAwAAAAAAAAAAAAAAAAAAA
AAAAAAD///8AewAAAAB7AAB7ewAAAAB7AHsAewAAe3sAvb29AHt7ewD/AAAAAP8AAP//AAAAAP8A
/wD/AAD//wAAAAAA////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
///////////////w/////////////////////zNs/L/vGObX6/D22wAA+ukAAvjDYWz8A3Rl+AJD
b/ACciDgAVzQ4AMRAOYPv+YnHwACB/8ABof/MoDj/zHg
<Url type="text/html" method="get" template="http://search.cpan.org/search">
  <Param name="query" value="{searchTerms}"/>
</Url>
</OpenSearchDescription>

CGI mit emacs

Ja, richtig gelesen: Mit Emacs kann man CGI-Programierung unter Apache betreiben. Und das ist sogar ziemlich einfach! Die neue Version 22 unterstützt in eLisp-Programmen das Unix-”Shebang” und die Kommandozeilenoption “–script”. Damit kann man nun Folgendes veranstalten:

Ein Skript wie dieses hier

#!/usr/bin/emacs --script

(princ "Content-type: text/html\n\n")

(defun h1(x)
  (concat "<h1>" x "</h1>"))

(defun p(x)
  (concat "<p>" x "</p>"))

(princ
 (concat (h1 "Emacs-Test")
                 (p  "This is served by Emacs 22")))

im cgi-bin -Verzeichnis des Apache ablegen. Nicht vergessen, Ausführungsrechte zu erteilen.

Und schon kann man Webseiten in Emacs-Lisp programmieren. Natürlich fehlt noch einiges. da so gut wie Alles zu Fuß gemacht werden muss.

Was das soll? Nun, Emacslisp ist bestimmt das am weitesten verbreitete Lisp auf der Welt und von den unbestreitbaren Vorteilen der Sprache kann natürlich auch die Internet-Programmierung profitieren. Die Geschwindigkeit ist übrigens auch im CGI-Betrieb überaschend hoch. Hier kann man sich von der kurzen Ladezeit überzeugen.