Sonntag, 22. Januar 2012

Die Untiefen des QIntValidators...

... oder auch: Wenn der Computer weiter denkt als der Mensch.

Für den Beitrag hier im Blog To GUI or not to GUI hat ich für das Qt4 / PySide eigentlich eine andere, kürzere Variante im Kopf.  Dabei sollte der try... except... Block wegfallen, weil für das Eingabefeld ein QIntValidator zum Einsatz kommen sollte. Dieser prüft, wie der Name schon vermuten lässt, ob eine Eingabe eine ganze Zahl ist bzw. Unterdrückt direkt die Eingabe von Buchstaben, Zeichen etc.

So weit, so gut. Hat aber nicht so funktioniert, wie ich dachte. Das zeigt auch das folgende, kleine Beispielprogramm:

#!/usr/bin/env python
# ~*~ coding: utf-8 ~*~

import sys

from PySide import QtGui

class MyClass(QtGui.QDialog):
    def __init__(self,parent=None):
        super(MyClass, self).__init__(parent)
        self.setWindowTitle('QIntValidator Test')
        layout = QtGui.QVBoxLayout()
        self.eingabe = QtGui.QLineEdit()
        self.eingabe_valid = QtGui.QIntValidator(0,1000,self)
        self.eingabe.setValidator(self.eingabe_valid)
        layout.addWidget(self.eingabe)
        self.button = QtGui.QPushButton(u'Echo')
        layout.addWidget(self.button)
        self.label = QtGui.QLabel(u'Echo...')
        layout.addWidget(self.label)
        self.setLayout(layout)
        self.button.clicked.connect(self.echo)

    def echo(self):
        wert = int(self.eingabe.text())
        return self.label.setText(unicode(wert))

if __name__ == '__main__':
    app = QtGui.QApplication(sys.argv)
    my_class = MyClass()
    my_class.show()
    sys.exit(app.exec_())

Dieses gibt einfach die Eingabe (welches eine ganze Zahl sein muss) wieder. Wird nun aber z.B. "1.1" oder "1,1" eingegeben, so wird - zumindest auf meinem System (Ubuntu 11.10 mit deutscher Spracheinstellung) - "11" zurück geliefert. Punkt bzw. Komma werden also entfernt.

Leicht verwirrt habe ich dann im deutschen Python-Forum nach Rat gefragt und der Nutzer "lunar" wusste auch, warum dieses Verhalten so ist. Die Langversion kann man im verlinkten Thread nachlesen, die Kurzfassung ist: Aufgrund der Spracheinstellung werden Punkt und Komma als gültige 1000er-Trennzeichen akzeptiert. Tauchen diese aber an der falschen Stelle auf (wie z.B. bei 1.1), dann wird es einfach ignoriert bzw. entfernt. Ergo: It's not a bug, it's a feature! Da muss man aber erst Mal drauf kommen... (zu Mal es in der PySide Doku nur sehr kurz erwähnt ist).

Wer einen "echten" Validator braucht, welcher wirklich nur die Ziffern von 0 bis 9 als Eingabe akzeptiert, der findet im oben genannten Thread direkt auch noch die passende Lösung, ebenfalls vom Nutzer lunar.

Mittwoch, 18. Januar 2012

To GUI or not to GUI...

Schaut man in den Programmierforen nach, so kommt von Einsteiger öfters die Frage: "Ich möchte mein erstes Programm schreiben, das auch eine GUI haben soll.". Eine oft gehörte Antwort ist dann: "Programmier' erst Mal ohne GUI".

Das mag befremdlichen klingen, da seit vielen Jahren eine grafische Benutzeroberfläche absoluter Standard ist. Warum soll man also nun für das (erste) eigene Programm darauf verzichten? Diese Frage wird im folgenden ein wenig beleuchtet.

Dazu gibt es folgende kleine Aufgabe: Es soll ein Programm geschrieben werden, welches eine ganze Zahl als Eingabe nimmt und das Quadrat dieser Zahl als Ausgabe zurück liefert. Um das Programm einfach zu halten und den Fokus auf "To GUI or not to GUI" zu legen, soll das Programm lediglich prüfen, ob die Eingabe eine ganze Zahl ist. Wenn nicht soll eine Fehlermeldung ausgegeben werden. Weiterhin enthalten die Quelltexte keinerlei Kommentare.

Als Programmiersprache kommt Python zum Einsatz, wobei sich die Beispiele  sicherlich auch recht einfach auf andere Sprachen übertragen lassen.

Zurück zu "Programmier' erst Mal ohne GUI": Selbst Linux-Nutzer, welchen die Kommandozeile tendenziell geläufiger ist als z.B. Windows-Nutzer, erscheint es vielleicht doch ein wenig antiquiert "nur Text" zu Arbeiten. Der Grund für den Rat hierzu ist aber recht simpel: Selbst eine minimale GUI (wie im folgenden zu sehen) verlangt einiges mehr an Codezeilen. Plus, und das ist der wichtigere Punkt, die Einarbeitung in eine entsprechende Bibliothek mit entsprechend umfangreicher Dokumentation kann zeitaufwendig sein. Das heißt, dass der geneigte Programmieranfänger nicht nur die Grundlagen einer für ihn neuen Programmiersprache lernen soll, sondern auch direkt die Nutzung der GUI-Bibliothek - was die Sache definitiv nicht einfacher macht. Außerdem wäre es ja auch Schade, wenn er frustriert aufgibt, weil er (als Anfänger) nicht mit der GUI-Programmierung zurecht kommt.

Bevor wir zu den verschiedenen Versionen des Programms kommen noch eine Anmerkung vorab: Vor den Listings ist immer die Anzahl der Codezeilen angegeben. Die beinhalten nicht den Shebang und die Coding-Info (welche bei allen Listings so wie so gleich ist), weiterhin werden Leerzeilen nicht mit gezählt. Codezeilen, welche Zeilenumbrüche zur Verbesserung der Lesbarkeit enthalten, werden ebenfalls als eine Zeile gezählt.

Alle Programm sind unter Ubuntu 11.10 Oneiric getestet, die verwendete Python-Version bzw. GUI-Bibliotheken und Python-Anbindungen stammen alle aus den offiziellen Paketquellen.

Der erste Kandidat ist ein reines Kommandozeilen-Programm. Dieses erwartet, dass die zu quadrierende Zahl als Argument beim Programmaufruf mit übergeben wird. Heißt das Programm z.B. "quadrat.py", so lautet der Aufruf:

python quadrat.py 12

Hier das Programm für die Kommandozeile, 12 Zeilen:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import sys

if len(sys.argv) < 2:
    print 'Es wurde kein Wert vorgegeben!'
    sys.exit()

eingabe = sys.argv[1]
try:
    zahl = int(eingabe)
except ValueError:
    print 'Der Wert ist keine ganze Zahl!'
    sys.exit()
else:
    print zahl * zahl


Update 21.1.2012:
Das obige Beispiel läuft zu ziemlich unter allen Python-Version, selbst unter sehr alten. Wer Python 2.7  bzw. 3.2 und neuer nutzt, der kann den Code noch kürzer gestalten, und zwar unter Verwendung des argparse-Moduls:

Kommandozeile mit argparse, 5 Zeilen:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import argparse

parser = argparse.ArgumentParser('Programm zum Quadrieren von Integerzahlen.')
parser.add_argument('value', type=int)
args = parser.parse_args()
print args.value * args.value


Danke an Hyperion für den Hinweis hierzu in deutschen Python-Forum!


Nun ist der Vergleich eines reinen Kommandozeilen-Programms vielleicht nicht ganz fair, weil dieses für jede Rechnung erneut aufgerufen werden muss. Die Programme mit grafischer Oberfläche müssen nur ein Mal gestartet werden, dann können beliebig viele Rechnungen durchgeführt werden.

Doch auch auf der Kommandozeile gibt es dafür ein pythonische Lösung, das cmd-Modul. Eine Einführung in dieses Modul ist im Blogeintrag cmd - Python-Modul für text-basierte Programme hier bei mir im Blog zu finden.

Die Umsetzung sieht dann so aus:

cmd-Modul, 14 Zeilen:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import cmd

class SimpleCmd(cmd.Cmd):
      
    def do_quadrat(self, line):
        try:
            zahl = int(line)
        except ValueError:
            print 'Der eingegebene Wert ist keine ganze Zahl!'
        else:
            print zahl*zahl

    def do_EOF(self, line):
            print 'Programm beenden...'
            return True

simplecmd=SimpleCmd()
simplecmd.cmdloop()

Kommen wir zu den GUI-Bibliotheken. Betrachtet werden hier die beiden wohl populärsten Frameworks, nämlich Qt4 und GTK+. Erster wird dabei über PySide genutzt, letzter über das PyGObject.
Pyside + Qt4, 27 Zeilen:

#!/usr/bin/env python
# ~*~ coding: utf-8 ~*~

import sys
from PySide import QtGui

class SimpleQt(QtGui.QDialog):
    def __init__(self,parent=None):
        super(SimpelQt, self).__init__(parent)
        self.setWindowTitle('Qt4')
        layout = QtGui.QVBoxLayout()
        self.eingabe = QtGui.QLineEdit()
        layout.addWidget(self.eingabe)
        self.button = QtGui.QPushButton(u'Quadrieren')
        layout.addWidget(self.button)
        self.label = QtGui.QLabel(u'Ergebnis...')
        layout.addWidget(self.label)
        self.setLayout(layout)
        self.button.clicked.connect(self.rechnen)

    def rechnen(self):
        wert = self.eingabe.text()
        try:
            zahl = int(wert)
        except ValueError:
            msgBox = QtGui.QMessageBox()
            msgBox.setText(u'Der eingegebene Wert ist keine ganze Zahl')
            msgBox.exec_()
        else:
            self.label.setText(unicode(zahl*zahl))

app=QtGui.QApplication(sys.argv)
simple_qt=SimpleQt()
simple_qt.show()
sys.exit(app.exec_())

Und hier noch die Version mit grafischer Oberfläche, welche auf GTK+ setzt:

PyGObject + GTK+, 29 Zeilen:

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from gi.repository import Gtk
 
class SimpelGtk(object): 
    def Gtk.Window.__init__(self, title='Simpel Gtk+')
        self.window.set_default_size(200, 100)
        vbox = Gtk.Box(False, 20)
        vbox.orientation = Gtk.Orientation.VERTICAL
        self.window.add(vbox)
        self.eingabe = Gtk.Entry()
        vbox.pack_start(self.eingabe,True,True,0)
        button = Gtk.Button("Quadrieren")
        button.connect("clicked", self.rechnen)
        vbox.pack_start(self.button,True,True,0)    
        self.label = Gtk.Label("Ergebnis...")
        vbox.pack_start(self.label,True,True,0)
        
    def rechnen(self,data=None):
        try:
            wert = int(self.eingabe.get_text())
        except ValueError:
            text = 'Die Eingabe ist keine ganze Zahl!'
            dialog = Gtk.MessageDialog(self, 0, Gtk.MessageType.ERROR,
            Gtk.ButtonsType.CANCEL, 'Fehler bei der Eingabe')
            dialog.format_secondary_text(
                'Der eingegebene Wert ist keine ganze Zahl!')
            dialog.run()
        else:
            self.label.set_text(str(wert*wert))

    def main(self):
        win = Gtk.Window()
        win.connect("delete-event", Gtk.main_quit)
        win.show_all()
        Gtk.main()
 
if __name__ == "__main__":
    e = SimpelGtk()
    e.main()
    
#http://python-Gtk-3-tutorial.readthedocs.org/en/latest/introduction.html

Wie zu sehen ist, sind die GUI-basierten Varianten deutlich länger, nämlich rund 2,5x länger als die Kommandozeile-Version und circa 2x so lange wie die Version, welche das cmd-Modul nutzt. Das mehr an Codezeilen ist dabei natürlich durch das Hinzufügen der GUI-Elemente bedingt. Weiterhin ist der Quelltext für Anfänger (wahrscheinlich) deutlich schwieriger nach zu vollziehen.

Nur damit keine Missverständnisse entstehen: Dies ist kein Plädoyer gegen Programme mit GUI. Überhaupt nicht. Es soll lediglich gezeigt werden, wodurch der oft gehört und gut gemeinte Rat "Programmier' erst Mal ohne GUI" motiviert ist.

Abgesehen davon: beherrscht man die Grundlagen einer Progammiersprache ist es oft deutlich einfacher, die APIs weiterer Bibliotheken wie z.B. den zur GUI-Erstellung, nachzuvollziehen.

Dienstag, 17. Januar 2012

Nomeansno "Mr. Wright and Mr. Wrong: One down and two to go" - Rezension

Zugegeben: ich dachte, ich kenne und habe alle Nomeansno Alben. Dieses hier, datierend auf 1994, ist mir dabei wohl entgangen... Jedenfalls habe ich es jetzt erst (online zusammen mit der Tour EP 2) erstanden).

Laut der englischen Wikipedia enthält das Album ein zu Zusammenstellung aus alten Songs (1979/1980), Liedern von den "Why do you call me Mr. Happy" Aufnahmen und ein paar neue Tracks (na ja, neu bezogen auf 1994...). Die meisten Tracks sind wohl von Rob und John Wright als Duo eingespielt, da Nomeansno 1994 keinen Gitarristen hat (Tom Holliston kam erst nach diesem Album offiziell zur Gruppe).

Der Release kommt so auf 16 Tracks und eine Spielzeit von ziemlich genau 60 min. Und, was soll ich sagen: 60 gute Minuten! Man hört zwar ein wenig, welche Songs älter sind, aber nichts desto trotz wird die Platte durchweg homogen. Was auch sehr schön ist: Die Platte zeigt sehr gut das gesamte Repertoire von Nomeansno, von schneller, punkrockiger Stücken über die etwas vetrackten "Jazzpunk" Sachen bis zu den langsamerer, melancholischen Songs.

Auch wenn man dein Eindruck haben könnte, dass hier die Reste zusammengekrazt wurden: Nein, wurde nicht. Jedenfalls ist der Release qualitativ ohne weiteres auf Augenhöhe mit den den anderen CDs / Platten von Nomeansno.

Fazit: Muss man haben. Keine Frage. Und Nomeansno ist bekanntlich so gut, dass das eigentlich jeder haben sollte. ;-)

Sonntag, 15. Januar 2012

Front 242 Live in Heerlen, NL, 14.1.2012

Falls sich jetzt jemand wundert, dass ich bei einem Front 242 Konzert war: Nein, ich höre keine EBM oder Elektro. Die einzigen Ausnahmen: manche Sachen KMFDM und eben Front 242. Wobei ich von letzteren nur zwei CDs besitzte, nämlich die beiden Live-CDs.

Vor 14 Jahren ich Front schon mal live in Bonn gesehen, in Bonn bei der :Re:Boot: Tour. Das war damals ziemlich genial. Jetzt war es dann wieder mal so weit: 14.1.2012, in Heerlen (Niederland).

Zur Location: Konzertort war das Theater in Heerlen. Ein richtiges Theater, aber moderner Bauart mit mehreren Räumen. Der "Limburger Zaal" (so der Name des Raums) fasst 600-800 Leute und ist breiter als tief. Sprich: jeder war nah an der Bühne. Auch gut.

Noch ein Wort zum Publikum: Jünger als 30 Jahre war glaube ich keiner, der Schnitt lag so bei ca. 40. Halt alles Front-Fans der ersten Stunden, die auch heute noch zu Front stehen.

Die Vorband war "Plastic Noise Experience". Gefälliger, intelligent gemachter Elektropop / EBM mit stark verzerrtem Gesang. Nicht schlecht, aber insgesamt ein bisschen statisch und ein bisschen fehlender "Bums".

Um ca. 21.30 Uhr war dann die Zeit reif für Front 242. Schon nach dem Intro war klar: Das wird gut! Super Sound, klar, prägnant, nicht zu laut. Und nach dem dritten Song ("Moldavia") war der ganze Saal in Bewegung. Und eins ist auch klar: Front 242 wissen, wie man ein gutes Konzert spielt. Fulminanter Start, zur Mitte hin etwas ruhiger und dann zum Ende noch Mal Vollgas. Die Songauswahl war ein geschickte Mischung aus den "Hits" (wie Headhunter, Im Rhythmus bleiben, Body to Body, Relgion) und anderen Stücken.

Was auch schön ist bei Front: Live werden die Stücke immer "aktualisiert". Das heißt, dass nicht einfach das Original 1:1 gespielt, sondern leicht variiert wird. Hier eine kleine Änderungen des Beats, dort ein modernerer Synthi-Sound. So klinge die Stücke immer frisch, interessant und "up-to-date", ohne jedoch den Bezug zum Original zu verlieren.

Das ganze wurde untermalt von einer sehr gut abgestimmten Licht- und Videoshow. Nicht minimalistisch, nicht bombastisch, sondern auf den Punkt präzise und perfekt zum jeweiligen Song passend.

Fazit: ein sehr gutes Konzert! Wer auf elektronische Musik steht, welche auch nur grob in Richtung EBM geht, der sollte sich Front 242 live anschauen. Denn: Die Show rockt richtig! 

Sonntag, 8. Januar 2012

kurze Zwischeninfo

Ein untrügliches Zeichen, dass ich mich an Unity gewöhnt habe: habe gerade unter Ubuntu 10.04 Lucid den Mauszeiger an den linken Bildschirmrand gefahren und gewartet, dass das Menü ausklappt. Oh Mann... Der Mensch ist halt ein Gewohnheitstier. ;-)

Für alle die sich jetzt wundern, wieso Lucid: Ich nutze Lucid zum Programmieren, weil die meisten Programme später auch auf einem Server unter Lucid laufen. Der aktuelle Ubuntu-Release (im Moment also Oneiric) wird für die "tägliche Arbeit" genutzt.

BTW: Das mit dem Mauszeiger und kein Menü kommt ist eine wahre Begebenheit.

Donnerstag, 5. Januar 2012

Nomeansno "Tour EP 2" - Rezension

Die Tour EP 2 ist zwar schon seit Sommer 2010 raus - aber ich habe sie erst in den vergangen Tage online in den USA gekauft. Vielleicht habe ich zu lange gewartet, dass Amazon das Ding endlich anbietet. Ist aber nicht der Fall. Wobei die aber komischerweise die Tour EP 1 haben. Egal.

Genau so wie die 1. EP enthält die Tour EP 2 ebenfalls vier Tracks. Während die Nr. 1 aber ziemlich ruhig ist, ist die Nr. 2 etwas rockiger. Rockig a la Nomeansno halt. Und recht "fröhlich".

Spieltechnisch und songtechnisch ist der Release auf gewohnt hohem Nomeansno Niveau. Ausgefuchstes Drumming, rollenden Basslinien, perfekt passende Gitarrenriffs und der bekannt Gesangsstil von Rob Wright. Alles halt, was Nomeansno ausmacht.

Die EP enthält insgesamt vier Tracks, mit einer Gesamtspielzeit von rund 25 min. Der 1. Track ist min 4 min recht kurz, die anderen drei liegen zwischen 6 und 8 min. Aber wer Nomeansno kennt weiß: auch wenn die Lieder lang sind wird's nicht langweilig.

Das Fazit ist klar: wer Nomeansno mag, der muss diesen Release auch haben. Wer Nomeansno nicht kennt hat so wie so was verpasst. ;-)

Geschichten von früher - und Unity

Mal eine kleine Geschichte von früher, aus den Anfängen meiner Linux-Zeit:
Das erste Linux, was ich häufiger genutzt habe, war Knoppix, Version 3.3. Das war so im Frühjahr 2004. Für alle, die damals noch nicht mit Linux unterwegs waren: Knoppix war seinerzeit ziemlich populär und auch in den Print-Medien recht präsent. Der Grund war wohl, dass Knoppix mit das erste ausgereifte Live-System war, was quasi jeder Computernutzer gefahrlos testen konnte.

Als Desktop setzte Knoppix damals noch auf KDE 3.x. Was für Windows-Nutzer - wie mich seinerzeit auch - angenehm war, weil die Bedienung recht ähnlich war. "Recht ähnlich" im Sinne von: Links unten gab es ein Icon, auf das man Klicken musste, damit sich das Menü mit den Programmen öffnet. Und die Menüstruktur war auch der von Windows ähnlich. Also zumindest in dieser Hinsicht war keine große Umstellung notwendig.

Beflügelt durch meine positiven Erfahrungen mit Knoppix habe ich mich dann ebenfalls für die Derivaten interessiert, die es seinerzeit auch schon gab. Eins davon war Gnoppix. Was nichts anderes war als ein Standard-Knoppix, nur das Gnome 2.x statt KDE als Desktop zum Einsatz kam. Nach dem 1. Booten und 10 Sekunden Benutzung war ich entsetzt: Was ist das denn für eine komische Menüstruktur?! Anwendungen? Orte? System? Und dann auch noch am oberen Bildschirmrand? Das geht ja gar nicht. Jedenfalls war die 1. Begegnung mit Gnome so erschreckend, dass ich die Gnoppix-CD nie mehr angepackt habe (und, wenn ich mich richtig erinnere, direkt entsorgte).

Aus heutiger Sicht kann ich das gar nicht mehr nachvollziehen. Mein 2. Kontakt mit Gnome im Form von Ubuntu 5.04 im Sommer 2005 verlief dann wesentlich erfolgreicher - und dauerhafter.

Und was hat das ganze mit Unity zu tun? Nun, nichts. Jedenfalls nicht direkt. Außer das manche Dinge (wie z.B. Desktop-Umgebungen, aber nicht nur) auf den ersten Blick vielleicht ganz furchtbar erscheinen, beim zweiten Blick gar nicht mehr so schlimm sind. Und das man vielen Dingen (wie z.B. Desktop-Umgebungen, aber nicht nur) auch mal eine zweite Chance geben sollte.

(Der geneigte Leser mag im vorherigen Abschnitt auch gerne "Unity" durch "Gnome 3" oder "KDE 4" ersetzen...).

Und zum Abschluss noch ein passendes Zitat:

"Humor is tragedy plus time" (Mark Twain)

Rückblickend finde ich meine erste Begegnung mit Gnome nämlich ziemlich lustig.