Darum Emacs: Markdown mode

Ich könnte vieles sagen, das ich an Emacs toll finde, aber ich werde mich hier auf ein einziges Bild beschränken:

Emacs mit Markdown Mode (und visual-line-mode); nur eine seiner kleineren Stärken, aber die, die mich heute gepackt hat.

E-Mail mit Emacs: web.de

Die Einrichtung von Emacs zum Verschicken von E-Mails hat mich etwas Zeit gekostet.

Bei web.de funktioniert das hier (EMAIL, NAME und PASSWORT ersetzen):

; email
(setq user-full-name "Arne Babenhauserheide"
       mail-from-style 'angles
       user-mail-address "EMAIL"
       mail-default-reply-to user-mail-address)
(setq user-mail-address "EMAIL")
(setq smtpmail-default-smtp-server 
       "smtp.web.de")
(setq smtpmail-local-domain nil)
; disable “we now use message mode” warning.
(setq compose-mail-user-agent-warning nil)
(setq compose-mail-user-agent-warnings nil)
(setq message-default-headers "BCC: EMAIL
")

(require 'smtpmail)

; MailMode
(setq send-mail-function 
    'smtpmail-send-it)
; MessageMode
(setq message-send-mail-function 
    'message-smtpmail-send-it)

(setq starttls-extra-arguments 
    '("--insecure" "--verbose"))
(setq smtpmail-auth-credentials 
   '(("smtp.web.de" 25 
   "NAME" "PASSWORT"))) 
(setq smtpmail-default-smtp-server 
    "smtp.web.de") 
(setq smtpmail-smtp-server "smtp.web.de") 
(setq smtpmail-smtp-service 25) 

Emacs als Tagebuch

Ich verwende nun seit einiger Zeit Emacs als Tagebuchprogramm. Mit ihm komme ich zum ersten Mal wirklich zum schreiben.

Der Aufruf bei mir ist schlicht

tagebuch

Den Grund, dass es für mich mit Emacs funktioniert, sehe ich darin, dass er mir genau das bietet, was ich brauche – und dabei verdammt schnell ist. Was ich brauche:

• Verschlüsselung ohne Aufwand (epa-file integriert transparentes GnuPG, also wirklich sichere Verschlüsselung).

• Sofort schreiben können (ist direkt bei der Zeile, bei der ich aufgehört habe).

• Schnell. Ich will nicht warten müssen, bevor ich tippen kann (geht über eine eigene Initfile, die Codevervollständigung und so rauslässt).

• Datum zum Eintrag (geht dank miniscript über „M-x datum“).

• (Auch) Auf der (Text-)Konsole. Wenn ich am Systembasteln bin, will ich trotzdem Schreiben können.

• Optional Versionsverwaltung (nur für backups; wenn es ein Mercurial repository gibt, speichere ich einen Schnappschuss via C-x v v).

Und wenn ich mal was wo anders nutzen will, kann ich es einfach via emacs rüberkopieren, trotz verschlüsselter Datei. Und es gubt keine temporären Dateien, die ich entschlüsselt rumliegen haben muss.

Und es passt sich der Farbgebung meiner Konsole an :)

Einrichtung

(benötigt emacs Version 23.1+)

Meine Einrichtung sieht so aus:

.babrc (alias):

alias tagebuch='/usr/bin/emacs \
-nw --no-init-file --no-site-file \
--load ~/.emacs-init-tagebuch \
~/pfad/zum/Tagebuch.txt.gpg'

Dazu habe ich die Datei ~/.emacs-init-tagebuch.

Um deinen eigenen Emacs so zu nutzen (unter GNU/Linux),

• kopiere einfach das Alias an deine ~/.bashrc,
• lade die ~/.emacs-init-tagebuch herunter und
• kopiere markdown-mode.el nach ~/.emacs.d/libs/markdown-mode/markdown-mode.el.

Das Alias erklärt

alias tagebuch='/usr/bin/emacs \
-nw --no-init-file --no-site-file \
--load ~/.emacs-init-tagebuch \
~/pfad/zum/Tagebuch.txt.gpg'

• -nw --no-init-file und --no-site file sagen: In der Konsole anzeigen und kein Standarddateien laden → deutlich schneller (Emacs kann unglaublich viel, aber einige Sachen machen es langsam; z.B. die vollständige Programmierumgebung).

• --load ~/.emacs-init-tagebuch: Fügt genau die Fähigkeiten hinzu, die ich brauche, keine mehr, keine weniger. Details weiter unten.

• Der Pfad ist klar. Die ~/.emacs-init-tagebuch richtet Emacs so ein, dass es jede Datei, die auf .gpg endet, transparent entschlüsselt (heißt, ich muss nur das Passwort eingeben, dann kann ich arbeiten, als wäre es nur eine normale Textdatei). Außerdem wird in Dateien mit Endung .txt.gpg Markdown-Syntax hervorgehoben und ist so schöner zu lesen und schreiben (daran habe ich mich schlicht gewöhnt und will es auch in meinem Tagebuch).

Die ~/.emacs-init-tagebuch erklärt

Die init-Datei aktiviert einige Features, die ich brauche:

Sie bindet mir den Markdown Mode ein, so dass ich Syntax-Highlighting habe.

(setq load-path (cons "~/.emacs.d/libs/markdown-mode" load-path))
(autoload 'markdown-mode "markdown-mode.el"
   "Major mode for editing Markdown files" t)

Dann aktiviert sie markdown für verschlüsselte Textdateien:

(setq auto-mode-alist
      (cons '("\\.txt\\.gpg" . markdown-mode)
    auto-mode-alist))

Dazu liefert sie schöne Zeilenumbrüche (am Wortende):

(global-visual-line-mode)

und aktiviert transparente Ver- und Entschlüsselung:

(require 'epa-file)
(epa-file-enable)

Außerdem habe ich mir eine kleine Lisp-Funktion geschrieben, die mir das Datum als Titel (zweite Ebene, H2 in HTML) in Markdown-Syntax ausgibt. Sie wird einfach mit M-x datum aufgerufen (im Code unten wird der Befehl durch das Schlüsselwort (interactive) aktiviert). Und ja, ich könnte hier alles einfügen, das ich in Lisp generieren kann. Also so gut wie alles :) (echte Programmiersprache)

(defun datum ()
  "print the current time in iso-format"
  (interactive)
  (insert (format-time-string "%Y-%m-%d %H:%M:%S") "\n-------------------\n\n"))

Abschließend legt sie fest, dass sich emacs die Zeilennummer merken soll (ich will beim nächsten Öffnen des Tagebuches wieder in der Zeile sein, in der ich aufgehört habe), dass ich keine Startinfo haben und Dateien in UTF-8 kodieren will (für Umlaute und Zeug wie ι∫→√).

(custom-set-variables
 '(current-language-environment "UTF-8")
 '(default-input-method "rfc1345")
 '(inhibit-startup-screen t)
 '(save-place t nil (saveplace)))

Damit habe ich ein Tagebuch-Programm, das alles kann, was ich brauche. Und wenn ich noch mehr brauche, kann ich das ohne Probleme später einfügen.

Viel Spaß beim Tagebuch-Schreiben mit Emacs!

Freenet-Project als Sicherheit für Informanten

→ Kommentar zu Journalismus: Chancen für Mistkratzer von DRadio Wissen.

Um die eigenen Informanten online wirklich zu schützen, können Journalisten mit ihnen über das Freenet-Project kommunizieren.

Dort kann niemand wissen, wer etwas bestimmtes geschrieben oder gelesen hat, aber es ist gesichert, dass die Veröffentlichende immer die gleiche ist.

Und entsprechend können Journalisten die Identität einer Informantin einmal offline prüfen und dann über Freenet in Kontakt bleiben. Die Informantin ist so selbst dann geschützt, wenn der Computer des Journalisten beschlagnahmt werden sollte.

Daher sollte Freenet-Kenntnis zum Handwerkszeug jedes Journalisten gehören.

→ http://freenetproject.org

Korrelation zwischen Freenet Nutzerzahlen und Google Trends zu Zensur

Ich habe eine kleine Grafik erstellt, die die Google News/Trends zu Zensur und die Zahl der Freenet-Nutzer gegenüberstellt. Das Ergebnis ist sehr aussagekräftig:

Die zwei blauen Linien sind von Google Trends, oben die Anzahl der Suchanfragen, unten die Erwähnungen in Zeitungen. Die anderen Linien stammen von Freenet Graphs mit Daten von Freenet Statistics (die beiden Links brauchen ein lokal laufendes Freenet, um zu funktionieren).

Die rote Linie oben ist die Gesamtzahl unterschiedlicher anonymer Freenet-IDs, die in 15 Tagen mehrfach gesehen wurden. Die grüne Linie sind die IDs, die mindestens einmal in 5 Tagen gesehen wurden (alle 5 Stunden wird eine Stunde lang gesucht). Die Lila Linie zeigt die Anzahl der IDs, die in 7 Tagen mehr als einmal gesehen wurden (also mehr einmal oder mehr als fünf Stunden online waren). Die blaue zeigt das gleiche für 5 Tage. Und die rote Linie ganz unten zeigt die Anzahl von IDs, die in einer Stunde gesehen wurden. Das ist also die Zahl der Nutzer, die zu jeder Zeit online sind.

Die beiden wichtigsten Punkte, die mir daran auffallen: Als Google aufgehört hat, in China zu zensieren, ist die Zahl der regelmäßigen Freenet-Nutzer sprunghaft um knapp 2000 gestiegen (von 5000 auf 7000) und als Google seine chinesische Lizenz erneuert bekommen hat, begann ein fast 2 Monate anhaltendes langsameres aber insgesamt fast genauso starkes Wachstum von etwa 7000 auf 8200 Nutzer. Dass die Gesamtzahl der Nutzer in der gleichen Zeit nur etwas stärker gestiegen ist (von etwa 20000 auf etwa 22000, bzw. von 23000 auf 25000) deutet an, dass vor allem lange laufende Knoten dazugekommen sind.

Die Daten lassen also den plausiblen Schluss zu, dass Freenet spätestens seit April 2010 für seinen eigentlichen Zweck genutzt wird: Um in repressiven Staaten der Zensur zu entgehen. Freenet ist also bereits heute ein Garant der Redefreiheit für etwa 4000 Leute. Und so wie sich die westlichen Staaten zur Zeit entwickeln, kann es gut sein, dass es bald auch in in unseren Breiten als Garant der Redefreiheit notwendig sein wird. Wikileaks wurde effektiv ohne Anklage und Prozess zensiert, und anderen könnte es sehr leicht genauso ergehen.

Neuere Daten zeigen übrigens, dass auch die Zensur von Wikileaks einen deutlichen Zustrom von Nutzern brachte:

Immerhin gibt es die cables von Wikileaks inzwischen mindestens zweimal in Freenet :)

(der kleine Bruch in den Linien kommt übrigens nur von einem kurzzeitigen Ausfall des Statistikrechners. Freenet lief problemlos weiter)

Nachdem ich jetzt erzählt habe, was andere machen: Wie sieht es mit dir aus? Willst du mit einem eigenen Freenet-Knoten mithelfen, Zensur auszuhebeln? → http://freenetproject.org/download.html

Die Installation geht schnell und schmerzlos. Das Netz braucht allerdings ein paar Stunden, um an Geschwindigkeit zu gewinnen (dein Knoten optimiert sich, solange du ihn laufen lässt, fortwährend). Wenn du dem Netzwerk helfen willst, schau, ob du deinen Knoten durchgehend laufen lassen kannst (mindestens 16 Stunden am Tag); dann funktioniert die Optimierung besser, du hast also auch höhere Geschwindigkeiten :)

Und wenn du ein paar Freunde hast, die auch mitmachen wollen, könnt ihr euch direkt über das Darknet verbinden. Dadurch gewinnen eue Freenet-Knoten nochmal massiv an Sicherheit dazu, und wenn jeder von deinen Freunden nochmal zwei oder drei andere Freunde für Freenet gewinnen kann, habt ihr bald ein nur über Freunde verbundenes Netz, das auch von außen kaum mehr zu entdecken ist. Klickt einfach auf den „einen Freund hinzufügen“-Link in euren jeweiligen Knoten, da steht alles erklärt (der Link hier führt direkt auf euren lokalen Knoten und funktioniert nur, wenn ihr schon ein Freenet lokal am laufen habt).

Viel Spaß in einer zensurfreien Welt!

Sone: Pseudonymes Microblogging über Freenet

Sone ermöglicht identi.ca / twitter-ähnliche Kurznachrichten über Freenet. Damit bietet es vollständig anonymes und skalierendes Microbloggen. Es ist noch im Beta-Stadium, funktioniert für mich aber bereits sehr gut.

(click for full size)

Zum Installieren braucht ihr ein laufendes Freenet → http://freenetproject.org

Dann einfach das Plugin WoT aktivieren und Sone aus dem Freenet laden:

USK@nwa8lHa271k2QvJ8aa0Ov7IHAV-DFOCFgmDt3X6BpCI,DuQSUZiI~agF8c-6tjsFFGuZ8eICrzWCILB60nT8KKo,AQACAAE/sone/-1/sone-current.jar

Plugins eintragen: http://127.0.0.1:8888/plugins/

Dazu benötigt ihr noch eine WoT-ID. Erstellen: http://127.0.0.1:8888/WoT/OwnIdentities

Meine öffentliche ID ist:

USK@6~ZDYdvAgMoUfG6M5Kwi7SQqyS-gTcyFeaNN1Pf3FvY,OSOT4OEeg4xyYnwcGECZUX6~lnmYrZsz05Km7G7bvOQ,AQACAAE/WoT/74

(im WoT eintragen auf http://127.0.0.1:8888/WoT/KnownIdentities )

In Sone bin ich auf

http://127.0.0.1:8888/Sone/viewSone.html?sone=6~ZDYdvAgMoUfG6M5Kwi7SQqyS-gTcyFeaNN1Pf3FvY

Bei Fragen, oder sollte irgendwas nicht laufen, könnt ihr einfach hier einen Kommentar schreiben oder mich über identi.ca erreichen.

PS: Sone wird aktuell sehr schnell weiterentwickelt. Folgt einfach der „sone“ ID, um Neuigkeiten mitzubekommen → http://127.0.0.1:8888/Sone/viewSone.html?sone=nwa8lHa271k2QvJ8aa0Ov7IHAV-DFOCFgmDt3X6BpCI

PPS: Die Lizenz ist die GPLv3 und der Quellcode ist unter https://github.com/Bombe/Sone/.

Verwendet Freenet (Programm)! Es ist zensurfrei, anonym und frei lizensiert

Nachdem die Politik immer mehr auf Zensur von allem möglichen drängt, gibt es die Gefahr, dass das internet zu einem vollständig kontrollierten Raum wird und Redefreiheit völlig verschwindet, weil jeder seine Aussagen vor dem Onlinestellen selbst auf mögliche Zensurgefahr prüft.

Das hat mit der Impressumspflicht angefangen, die sagt, dass jede Seite ein Impressum tragen muss, obwohl der Betreiber für die Polizei sowieso leicht zu ermitteln ist.

Dann ging es weiter mit Abmahnwellen.

Und jetzt kommt die direkte und nicht prüfbare Zensur.

Da die Entwicklung nicht so aussieht, als könnten wir sie in den nächsten Jahren rückgängig machen, sollten wir eine Möglichkeit haben, unseren Protest gegen die Zensur in einer zensursicheren Umgebung zu organisieren.

Freenet (das Programm, nicht der Provider) bietet dabei ein sicheres Baumhaus, in dem die Redefreiheit gewahrt bleibt, denn es lebt auf den Rechnern der Beteiligten, und solange ein Beitrag Leute interessiert, kann er nicht entfernt werden. Gleichzeitig kann niemand herausfinden, von wem die Inhalte (Webseiten) geschrieben wurden und wer sie liest.

Wenn es im Darknet-Modus genutzt wird, kann außerdem niemand (ohne massiven Aufwand) herausfinden, ob jemand am Freenet teilnimmt, denn jeder kennt nur seine direkten Kontakte.

Und es ist frei lizensiert und für Windows, MacOSX und GNU/Linux verfügbar, so dass jeder sich an der Entwicklung beteiligen kann, wenn sie ihm wichtig ist (und er programmieren kann).

• http://freenetproject.org

In anderen Ländern wurden schon zensurkritische Weblogs zensiert. Die Wahrscheinlichkeit ist recht hoch, dass das bei uns auch passiert.

(ich habe diesen Beitrag ursprünglich im Heise.de Forum geschrieben - als Kommentar zu einem Beitrag, darüber, dass Zypries das Recht auf Privatkopie in Frage stellt und rechtlich durchsetzbare "Good-Internet-Kodices" will.

Automatische Aktualisierungen in Gentoo GNU/Linux

Um mein Gentoo mit minimalem Wartungsaufwand aktuell zu halten verwende ich tägliche und wöchentliche Cron-Scripte.

Das tägliche Update läuft über pkgcore, um wichtige Sicherheitsupdates zu installieren:

pmerge @glsa

Damit installiert mein Rechner die Gentoo Linux Security Advisories, d.h. die wichtigsten Sicherheitsupdates (Damit das Script läuft brauchst du pkgcore: "emerge pkgcore")

Anmerkung: Es könnte sinvoll sein, den lafilefixer zu diesen Skripten hinzuzufügen Quelle).

Das folgende Skript ist mein tägliches update (in /etc/cron.daily/update_glsa_programs.cron )

Daily Cron

#! /bin/sh


### Update the portage tree and the glsa packages via pkgcore

# spew a status message
echo $(date) "start to update GLSA" >> /tmp/cron-update.log

# Sync only portage
pmaint sync /usr/portage

# security relevant programs
pmerge -uDN @glsa > /tmp/cron-update-pkgcore-last.log || cat \
    /tmp/cron-update-pkgcore-last.log >> /tmp/cron-update.log

# And keep everything working
revdep-rebuild

# Finally update all configs which can be updated automatically
cfg-update -au

echo $(date) "finished updating GLSA" >> /tmp/cron-update.log

Und hier ist mein aktuelles wöchentliches Cron (in /etc/cron.weekly/update_installed_programs.cron):

## Weekly Cron

#!/bin/sh


### Update my computer using pgkcore, 
### since that also works if some dependencies couldn't be resolved.

# Sync all overlays
eix-sync

## First use pkgcore
# security relevant programs (with build-time dependencies (-B))
pmerge -BuD @glsa

# system, world and all the rest
pmerge -BuD @system
pmerge -BuD @world
pmerge -BuD @installed

# Then use portage for packages pkgcore misses (inlcuding overlays) 
# and for EMERGE_DEFAULT_OPTS="--keep-going" in make.conf 
emerge -uD @security
emerge -uD @system
emerge -uD @world
emerge -uD @installed

# And keep everything working
emerge @preserved-rebuild
revdep-rebuild

# Finally update all configs which can be updated automatically
cfg-update -au

Gentoo auf iMac Flat-Screen 1,25Ghz

Ich habe gestern die Installation von Gentoo auf dem iMac meiner Frau begonnen.

Gestern habe ich die 2008.0 Universal-CD gebrannt und den iMac damit gebootet, die letzten 15 Minuten habe ich damit zugebracht, den "Gentoo" Eintrag auf meiner Seite zu schreiben, also sind wir gerade bei etwa

T=30 Minuten

Der tar-ball ist ausgepackt. Ich formatiere die Platten nicht neu - vielleicht kann ich so die Daten aus Kubuntu erhalten (ja, ich habe ein Backup der wichtigen Daten). update: Hat geklappt. Alle Daten sind noch da.

Bisher hat alles reibungslos geklappt - das einzige Manko ist, dass in den docs noch lynx als Browser empfohlen wird, die CD aber stattdessen links2 hat. Muss ich noch einen Bugreport aufmachen.

T ~ 60 Minuten

Alle vorherige Kubuntu Software entfernt (rm -r /usr /lib /lib64 ..., /home ausgespart!), den stage tarball und portage snapshot installiert, changeroot ausgeführt, portage aktualisiert und die notwendige Konfiguration geschrieben - es wird ein Desktop Profil.

Jetzt kommt der Kernel.

T ~ 2 Stunden

Ich habe statt dem Befehl "genkernel -genzimage all" einfach "genkernel all" genutzt, weil der erste nicht funktioniert hat. Vielleicht ein Bug in der Anleitung?

Von der Stunde musste ich selbst nur etwa 10 Minuten was machen, den Rest hat der Rechner mit zweimal kompilieren des Kernels verbracht (einmal falsch wegen hoffentlich falschem Befehl).

T ~ 4 Stunden

Es war nicht mehr allzu viel zu tun. yaboot wollte mit "yaboot -b /dev/hda2" gestartet werden, weil meine apple bootpartition auf /dev/hda2 liegt.

Dann habe ich noch die locale eingestellt (/etc/locale.gen braucht "de_DE.UTF-8@euro UTF-8", damit /etc/env.d/02locales "de_DE.utf8@euro" nimmt).

Ein bisschen musste ich noch Programme bauen, aber das macht mein Rechner ohne dass ich ihn überwachen muss.

Ich muss aktuell noch beim booten "Linux video=ofonly" eingeben, wenn ich die Konsolen sehen will, weil ich noch nicht den richtigen Grafikmodus habe. Ich hoffe, ich kann das bald fixen. Bis dahin stört es nicht. Der X-Server funktioniert und kdm wird sauber angezeigt, sobald der Rechner fertig gebootet ist.

Und jetzt gerade läuft das "emerge -uDN world", um alle bisherigen Programme zu aktualisieren. Als nächstes werden dann xorg-x11 und kde-meta emerged :)

Erstmal wird es noch kde 3.5.x, weil 4.1.2 für ppc noch nicht in testing ist.

Update: Inzwischen läuft alles. Ich musste noch ein paar Programme nachinstallieren (z.B. Firefox und OpenOffice), aber damit ist die Installation abgeschlossen. Alle alten Daten und KDE Einstellungen funktionieren weiterhin, trotz der Neuinstallierung.

Die gesamte Installation hat etwa 2 Tage gedauert - davon alles bis auf die ersten 4 Stunden und etwas Konfiguration (z.B. X via xorgcfg und WLAN) reine compile-Zeit.

Was meiner Frau noch fehlte waren gimp, openoffice, mozilla-firefox und k3b. Ich brauchte noch sudo, screen, cfg-update, eix, euses, gentoolkit und portage-utils. :)

WLAN habe ich über net-wireless/b43-fwcutter , net-wireless/bcm43xx-fwcutter und wpa_supplicant zum Laufen bekommen. Glücklicherweise hatte ich von meiner alten installation noch eine Kopie der Apple WLAN Firmware auf der Platte.

Update 2009-07: xorg braucht für Tastatur und Maus jetzt x11-drivers/xf86-input-evdev.

Update: Infos zur installation von WLAN auf den alten G3 iMacs Flatscreen gibt es im Gentoo Wiki.

KDM (Login) Tastaturlayout auf Neo umstellen

Ich habe mein Haupt-Tastaturlayout auf Neo umgestellt und die Tastatur umgebaut. Da ich etwas suchen musste, bis ich herausgefunden habe, wie ich es auch in KDM das Neo-Layout nutzen kann, schreibe ich es hier.

Damit das hier funktioniert, musst du "evdev" als Tastaturtreiber nutzen.

Als ersten Schritt muss eine Tastaturlayout-Dateien in /etc/hal/fdi/policy/ sein. Wenn da keine keymapfdi Datei liegt, kopier dazu einfach den folgenden Befehl in die Konsole:

sudo cp /usr/share/hal/fdi/policy/10osvendor/10-keymap.fdi \
/etc/hal/fdi/policy/

Dann schau in die Datei /etc/hal/fdi/policy/10-keymap.fdi und änder die Zeilen

<merge key="input.xkb.layout" type="string">de</merge>
<merge key="input.xkb.variant" type="string" />

so dass sie das folgende enthalten (nur die zweite ist geändert):

<merge key="input.xkb.layout" type="string">de</merge>
<merge key="input.xkb.variant" type="string">neo</merge>

Voilà, dein X-Server fängt jetzt mit dem Neo-Layout an, und auch KDM nutzt das Neo Layout.

Ausführlichere Informationen und Hintergrund gibt es im Gentoo Leitfaden zum Xorg 1.5 update.

Effektiv heißt es: Du verwendest jetzt die Neo-Variante.

Notiz: Damit das hier funktioniert, musst du Neo bereits installiert haben. Falls du es noch nicht hast, findest du im Neo-Wiki einen Beitrag zum installieren und einrichten von Neo unter GNU/Linux.

Vorsicht: Um nicht am Ende mit nicht-eingebbaren Passwörtern dazusitzen, solltest du dir für den Anfang entweder vorher ein Neo-Layout ausdrucken (zum Beispiel den Aufsteller), oder deine Tastatur umbauen, damit du nachschauen kannst, wo die Tasten liegen, falls du es mal vergessen solltest.

KDE 4

Ich teste nun schon länger KDE 4, aber erst heute ist es meine Normalumgebung geworden.

Es hat noch einige Macken, aber es fühlt sich so viel angenehmer an, dass ich nicht mehr zurück zu KDE 3.5 will.

Gut, ich kann noch keine Mails abrufen, so dass ich doch dann und wann zurück müssen werde, aber ich habe vor ab jetzt alles mit KDE 4 zu machen, das damit bereits geht, denn ich fühle mich einfach wohl darin.

Ich habe es mir in meinem Gentoo installiert, sobald KDE 4.0 verfügbar war (es war fertig um 22:31:34 am 22.01.2008), und vorher häufiger die Subversion Version getestet.

Und der Unterschied von der SVN Version zum Release ist gewaltig!

Als Fazit kann ich aber einfach sagen, dass sich KDE 4.0 noch mal sehr viel glatter und angenehmer anfühlt als KDE 3.5, und das Amarok2 Preview läuft :)

Der Unterschied ist ähnlich gewaltig, wie der als ich damals von MacOS9 auf MacOSX gewechselt bin, und ich habe das Gefühl, dass es mir den Komfort wiedergibt, den ich damals aufgegeben habe, als ich von Mac weiter zu Linux gewechselt bin, weil mir Apple meine eigenen Entscheidungen zu sehr eingeschränkt hat (was ist der SInn dahinter Configdateien binär zu machen, außer den Nutzer an Änderungen zu hindern?).

Viel Spaß beim Testen, falls auch ihr einen Blick auf KDE 4 werfen wollt!

Für den Fall, dass es euch interessiert, wie es bei mirnun aussieht, habe ich euch einen Screenshot angehängt: KDE4.0 mit Systemsettings und Dolphin.

Ich habe die Fraben auf "Stone Orchid" umgestellt (etwas dunkler), weil ich damit die Fensterrahmen angenehmer finde und das Gefühl habe, besser damit arbeiten zu können.
Ansonsten ist es ein Standard KDE 4 Desktop mit Systemsettings und Dolphin.

Aber erinnert euch daran, dass die Programmierer sagen, dass es noch nicht für den Produktiveinsatz genutzt werden sollte - ich werde mich auf jeden Fall daran erinnern, wann immer Fehler auftreten. :)

Viel Spaß!

KDE 4.1

Gestern (und vorgestern) hat mein KDE 4.1 rc1 problemlos gebaut, und ich habe nun einen wundervollen Desktop vor mir, und den möchte ich euch nicht vorenthalten.

Klickt auf das Bild, um es in voller Schönheit (und Auflösung) zu sehen :)

Abgesehen von dem tollen Aussehen scheint auch so gut wie alles zu funktionieren, obwohl ich Kontact noch nicht eingerichtet habe und deswegen darüber noch nichts sagen kann (ich will KDE4 erstmal zum Arbeiten haben, und davon halten mich Mails zu effizient ab :) ).

Einziges Manko bisher: Plasma widgets aus dem Netz laden funktioniert noch nicht.

Aber der Arbeitsfluss ist klasse, und ich hätte nicht gedacht, das Folder-View so praktisch ist!

Nebenbei: Installiert in Gentoo via Portage (Overlay).

KDE 4.3.3

Ich dachte, es wäre mal wieder an der Zeit für einen aktuellen Screenshot:

Klick einfach auf das Bild, um es in voller Größe und Schönheit zu sehen :)

Lizenzausnahme: DIeses Bild steht nicht unter der GPL, da dafür meine Frau noch ihr Einverständnis geben müsste. Daher ist hier eine Version, in der das Bild von uns beiden ausgeblendet ist, so dass die Version unter der GPL verwendet werden darf:
screenshot-dragons-ghost-gpl.png

Was ich nutze:

• Gentoo + KDE 4.3.3
• mit Aurorae Theme Engine als Fensterdekoration mit der Ghost-deco, und
• dem Ghost Plasma Theme,
• dem Obsidian Coast Farbschema (KDE standard),
• den Buuf Icons, und
• dem "Dragons" Hintergrundbild von Gertrud Wenzel / 1w6.org (GPLv3). -> Dragons für große Bildschirme

Mit den Plasmoids:

• Folderview / Ordneransicht
• CWP (configurable weather plasmoid)
• Luna (Mond im Dock)
• Notizen
• Umgangssprachliche Uhr / Fuzzy clock
• Eieruhr
• Bilderrahmen mit dem einzigen Bild meiner Frau, das ich veröffentlichen darf :)

Die Hintergrund-Farbe ist #2E3436 (aus der Oxygen Palette).

KDE 4.5 rc1 Bildschirmfoto mit Infos zum Selbermachen

Und mal wieder ist es Zeit für einen Screenshot, diesmal von KDE SC 4.5 release candidate 1:

Klick einfach auf das Bild, um es in voller Größe und Schönheit zu sehen :)

Im Gegensatz zu meinem Screenshot von KDE 4.3.3 nutze ich diesmal fast nur Standardeinstellungen, weil ich wieder stärker sehen will, wie sich das Standard-KDE entwickelt.

„Quell“ und „Projekte“ sind Ordneransichten, in denen ich Aliase (symlinks) zu meinen meistzugegriffenen Ordnern angelegt habe. In Quell sind das Ordner zu wichtigen Kategorien meiner Ordnerstruktur (Quell ist auch mein Startordner in Dolphin) und in Projekte zu Projekten, an denen ich aktuell arbeite.

Der Hintergrund ist wieder das Drachen-Wallpaper auf Grundlage des Logos, das Trudy Wenzel für das freie 1w6-System gezeichnet hat (andere Auflösungen: 800x600 bis 2560x1600) mit #000433 als Hintergrundfarbe.

Das Bild unten rechts ist das „Bilderrahmen“ Plasmoid und stammt ursprünglich aus Battle for Wesnoth, einem freien Strategiespiel. Alle 5 Minuten wechselt das Bild zufällig zu einem der Wesnoth-Bilder, die wir für das freie 1w6-Rollenspielsystem verwenden (1w6-System).

Unten links ist das Plasmoid „Wetterbericht“, eingestellt auf ‚Mannheim, Baden-Württemberg (google)‘.

Unten rechts dann „Notizen“, und in der Mitte über der Hüfte des linken Drachen „Luna“, das mir immer die aktuelle Mondphase anzeigt (weil ich das einfach interessant und schön finde).

Schlussendlich ist noch die Kontrollleiste etwas schmaler, weil ich so stärker das Gefühl habe, dass sie eine Interaktionsstruktur ist (und ich dadurch Programmfenster nach links unten schieben kann, so dass sie von keinen anderen überlappt werden – fürs Verschieben von Dateien sehr praktisch :) ).

Die Icons sind einfach Standard-Oxygen.

Installiert ist das ganze über den kde-testing-overlay in Gentoo: emerge layman && layman -a kde && emerge @kde-4.5

Den Screenshot habe ich mit ksnapshot gemacht: Alt-F2 → ksnapshot.

Und das wars auch schon – ich hoffe, die Infos waren interessant für dich! Wenn ja, würde ich mich über einen Kommentar freuen! (und sei er nur „schönes setup“ :) ).

Viel Spaß mit KDE!

KDE in Gentoo

Hier finden sich Sachen zu KDE in Gentoo.

update: kdelibs 4.3.1 sind jetzt amd64 stable. Damit ist KDE 4.3 die Standard-KDE-Version in Gentoo.
-> http://gentoo-portage.com/kde-base/kdelibs

Inzwischen ist KDE 4.1 im portage tree.
-> http://forums.gentoo.org/viewtopic-t-708282.html

In den Gentoo Foren:

• KDE 4.1 in Gentoo with Portage.

Um KDE 4.1 (und spätere via SVN) in Gentoo zu testen, nutzt einfach layman, wie im Forum Thread beschrieben.

Dann viel unmasken und keyworden...

BSD und GPL in einfachen Worten

→ Geschrieben auf heise.de.

Sowohl in BSD-Lizenzen als auch in der GPL steht „die Lizenz dieses Teils muss erhalten bleiben“.

BSD Lizenzen sagen „mach was du willst, lass nur hier den Lizenzheader drin.“

Die GPL sagt „mach was du willst, aber du musst das was du daraus machst unter die gleiche Lizenz stellen.“

(das war die Kurzform - der Rest sind rechtlich notwendige Details um das zu ermöglichen)

Wenn ich etwas veröffentliche, dann unter der GPL, denn wenn jemand von meiner Gratisarbeit profitiert, um etwas eigenes zu schaffen, dann will auch ich wieder von dem profitieren, was er daraus erstellt.

Und da potenziell hunderte von Leuten daran arbeiten (siehe Wikipedia), genügt ein "ich will dann auch" nicht, sondern muss ersetzt werden durch "jeder Nutzer hat die gleichen Rechte wie der ursprüngliche Autor".

Bei der GPL stehen sich alle Autoren auf Augenhöhe gegenüber. Jeder hat die gleichen Rechte. Das nennt sich dann „freie Werke“ – sie sind frei und sie bleiben frei.

Bei BSD Lizenzen stellen sich die Autoren als Schenker hin, die am Ende oft die Gelackmeierten sind, weil viele Leute nichts zurückgeben. Das nennt sich "vogelfreie Werke" - sie sind vogelfrei und jeder kann sie einfach nehmen.

Kurze Einführung in Mercurial mit TortoiseHG (GNU/Linux und Windows)

Das Repository herunterladen

Wenn du TortoiseHG installiert hast, kannst du dir das Repository auf den Rechner laden, indem du in einem Ordner rechtsklickst und im Menü "TortoiseHG" die Option "Clone" wählst (Aktuell brauchst du für den Dialog noch Windows, die anderen gibt es auch in GNU/Linux).

Rechtsklick-Menü, Windows:

Clone, GNU/Linux:

In dem Dialog gibst du einfach die URL des Repositories ein, also z.B.

http://www.bitbucket.org/ArneBab/md-esw-2009

ein (das ist auch direkt die Adresse des Repositories im Netz).

Wenn du dich auf bitbucket.org anmeldest, findest du eine clone-Adresse direkt auf der Seite, über die du auch Änderungen hochladen kannst (sie enthält deinen Login - ich kann dir auf der Seite "push" Zugang geben).

Arbeitsfluss mit TortoiseHG

Du hast damit zwei grundlegende Möglichkeiten: Änderungen lokal speichern, zwischen den Änderungen vor und zurück wechseln, und Änderungen mit anderen synchronisieren (ich vermute ich erzähle dir gerade zum Gutteil reduntantes Zeug, aber ich schreibe dann doch lieber zu viel als zu wenig - wenn ich schon viel zu selten zum Schreiben komme :) ).

Um Änderungen zu speichern, kannst du einfach im Rechtsklick Menü (in dem Ordner) "HG Commit" wählen. Wenn Dateien HG noch nicht bekannt sind, musst du sie mit "Add Files" einfügen (Die Checkbox neben der Datei anklicken), damit du sie committen kannst.

Um zu früheren Änderungen zurück zu gehen, kannst du im "TortoiseHG" Menü "Checkout Revision" nutzen. In dem Dialog kannst du dann die Revision auswählen, zu der du willst, und das Icon links oben nutzen, um die Dateien im Ordner auf die Version zu bringen.

Synchronisieren kannst du, indem du rechtsklickst und im Menü "TortoiseHG" den Punkt "Synchronize" wählst. In dem aufspringenden Dialog kannst du "pushen" (Updates ins Netz laden - Pfeil hoch mit Strich drüber), "pullen" (Daten auf deinen Rechner ziehen - Pfeil runter mit Strich drunter), und z.B. schauen, was du pullen würdest. Ich denke, dass den Dialog zu nutzen schnell natürlich wird.

Viel Spaß mit TortoiseHG! :) - Arne

PS: Es gibt dazu im Netz auch eine englische Einführung in TortoiseHG und einen englischen Überblick zu DVCS.

PPS: md-esw-2009 ist ein Repository in dem Baddok und ich eine gemeinsame Runde Mechanical Dream geplant haben.

PPPS: Auf meinen englischen Seiten habe ich nun auch eine englische Version dieses Artikels.

Leistungstests und Vergleiche, DVCS: Mercurial (hg) vs. Git vs. Bazaar(bzr), ...

Vergleiche | Comparisions

Englisch

• Mercurial vs. Git commit performance for use in server-applications - a comparision which takes the commit, add and garbage collect times into account.
• McGyver vs. James Bond - A comparision with nice anlogies - and it reads well founded.
• Managing your home directory.
• Tests with changed files including push and pull.
• Explanation and comparision.
• On the Linux code tree.
• Text from Bazaar about advantages over Git.
• Text from Bazaar about advantages over Mercurial -> Answer from Mercurial.
• Weblog posts from Gnome folks.
• The 'better scm' comparision between many SCMs.

Deutsch

• mein eigener Test zu lokalen Operationen Mercurial vs Git

Warum Mercurial | Why Mercurial

Links zu Leuten, die schreiben, warum sie sich für Mercurial entscheiden haben.

• http://www.dribin.org/dave/blog/archives/2007/12/30/why_mercurial/

Webseiten einfacher aktualisieren mit Mercurial und lftp

-> Webseiten auf den FTP-Server laden wird einfach "hg push".

Ich schreibe seit langem eigene Webseiten, und die Notwendigkeit, sie jedesmal von Hand auf den Server hochzuladen, wenn ich etwas geändert hatte, war mir seit Jahren ein Dorn im Auge.

Vor kurzem habe ich nun angefangen, die Webseiten mit Mercurial als Versionsverwaltung zu bearbeiten, und Mercurial hat eine sehr praktische Funktion: Hooks (also Anker).

Damit kann ich einen Befehl ausführen, wenn ich in meiner Versionsverwaltung eine bestimmte Handlung ausführe.

Ich verwende sie, um meine Webseiten direkt auf den FTP-Server zu kopieren, sobald ich Änderungen in Mercurial "push"e.

Das heißt, sobald ich eine Webseite so weit aktualisiert habe, dass ich sie veröffentlichen will, gehe ich nur kurz in die Konsole und tippe

hg push

und schon landet meine Webseite automatisch aktualisiert auf meinem FTP-Server.

Und wenn ich nichts geändert habe, merkt Mercurial das und ruft den FTP nichtmal auf.

Damit es auch bei euch funktioniert, braucht ihr nur Mercurial und lftp. Ich bin mir sicher, es geht auch ohne lftp, aber damit geht es bei mir gut, und es war schnell installiert. Warum sollte ich mir die Arbeit machen, wenn es andere schon für mich gemacht haben?

-> Mercurial: http://www.selenic.com/mercurial/
-> lftp: http://linux.maruhn.com/sec/lftp.html

Danach müsst ihr nur noch das folgende in hgrc im Repository der Webseite eintragen (in ".hg/hgrc" - Zeilen, die mit "#" anfangen, sind Kommentare):

default-push müsst ihr noch für euch anpassen. Bei mir nimmt es mein Mercurial repo auf freehg.org

------ ------ Datei ------ ------
[paths]
# default-push = http://USER:PASSWORD@freehg.org/u/ArneBab/erynnia/

[hooks]
# Update my website automatically when I push the repo.
# Explanations: lftp -c 'COMMAND'
# COMMAND:
# open CMD -u USER,PASSWORD FTP_SERVER
# CMD:
# -R: Reverse -> local_source remote_source
# -X GLOB: Glob: Shell-style -< exclude the .hg dir

outgoing = lftp -c 'open -e "mirror -R -X .hg/ ABSOLUTER_PFAD_LOKAL RELATIVER_PFAD_FTP" -u USER,PASS ftp://FTP_SERVER '

------ ------ /Datei ------ ------

Und schon ist es nur noch "hg push", um die Webseiten zu aktualisieren.

Und es wird nur hochgeladen, was sich geändert hat (dank lftp).

Effektiv ist das ein "push content to FTP" mit Mercurial.

Viel Spaß!

PS: Wenn du Webseiten mit noch weniger Aufwand basteln willst, kannst du deine Webseiten auch mit pyMarkdown_Minisite schreiben, einem Projekt, das ich gestartet habe, weil ich nicht alles in HTML kodieren und trotzdem einfache und schön aussehende Webseiten haben wollte. Die Technik in diesem Artikel nutze ich dabei zum automatischen hochladen der Seiten.

Blob Schwarm

Ich habe einen kleines Programm geschrieben, das einen interagierenden Schwarm von Blobs zeigt.

Jeder der Blobs sucht sich am Anfang einen Partner und nähert sich ihm.

Wenn die beiden Partner sich zu nahe kommen, flieht einer von ihnen und sucht sich einen neuen Partner, dem er sich wieder annähert, bis er ihm zu nahe kommt.

Durch diese brechenden Zweierbeziehungen bleiben die Blobs zusammen, das heißt es entsteht ein Schwarmverhalten, obwohl jeder Blob nur an seinen aktuellen oder nächsten Partner denkt.

Das ganze ist in Python und pyglet (GUI) implementiert. Die einzige Abhängigkeit ist Python 2.5.

Wenn du es anschauen willst, lade dir einfach den Blob Schwarm herunter, entpacke sie und klick in dem Ordner die Datei blob_swarm.pyw an.

Alles andere sollte von selbst gehen.

Viel Spaß!

Blob Valentine

Ein kleines Geschenk, das ich meiner Frau zum (bzw. am) Valentinstag 2008 geschrieben habe.

In seiner Gänze kann es allerdings in diesem Screenshot nicht genossen werden. Um das ganze animiert zu haben, musst du schon das Programm runterladen :) (es braucht nur Python (>=2.5) ).

-> Blob Valentine 0.3 herunterladen

Essenzielle Infos zu Python (mMn)

Hier führe ich Links und Texte, die meiner Meinung nach (mMn) essenziell für Python-Programmierer sind.

Die Liste wird sich wohl langsam erweitern.

Allgemein ist der Link zu den python Tools im SVN wichtig. Er enthält so interessante Dinge wie pygettext.py (das ich vorher stundenlang gesucht habe)...

• Python-SVN Tools

Angefangen mit Übersetzung (l10n) und Internationalisierung (i18n), vll. irgendwann auch Multinationalisierung (m17n).

• 21.1.3.2 Localizing your application - Python Library Reference.
  • Detaillierter

  • Übergeordnet (mit Locale)
• Internationalizing Python (en) - von Martin von Löwis, Humboldt-Universität zu Berlin
• Python, wxPython and internationalization (i18n)

Geschwindigkeitstest - eine Liste summieren, selbstgeschrieben oder mit sum()

Hier teste ich kurz, wie lange ein selbstgeschriebenes Programm zum summieren einer Liste von Zahlen braucht und vergleiche sie mit der mitgelieferten Funktion sum().

Die Funktionen, die ich nutze sind:

def summieren(liste): 
	"""Summiere alle Zahlen der Liste manuell."""
	# erst brauchen wir einen Zähler, 
	# auf den wir alle Zahlen aufsummieren.
	gesamt = 0
	# Dann summieren wir 
	# alle Zahlen der Liste zu dem Zähler. 
	for x in liste: 
		# Das heißt, wir erhöhen ihn
		# für jede Zahl in der Liste um die Zahl. 
		gesamt += x
	# und geben ihn dann zurück. 
	return gesamt

und

def summieren(liste): 
	"""Summiere alle Zahlen der Liste mit sum()."""
	return sum(liste) 

Die benötigte Zeit teste ich, indem ich die Funtion in einem doctest jeweils 100001 mal ablaufen lasse und prüfe, wie lange python braucht, um das Skript zu auszuführen.

Die vollständigen Quelltexte habe ich an die Seite angehängt.

Die Aufrufe sind damit:
time python summieren_selbst.py # Selbstgeschriebener Code
time python summieren_sum.py # Eingebaute Funktion

Und ich erhalte die Ergebnisse:

$ time python summieren_selbst.py

real 0m7.536s
user 0m7.430s
sys 0m0.030s

$ time python summieren_sum.py

real 0m4.362s
user 0m4.260s
sys 0m0.070s

Damit braucht meine selbstgeschriebene Summierfunktion etwa 74% länger als die eingebaute.

Fazit: Ich konnte mir bestätigen, dass es besser ist, die eingebaute Funktion zu nutzen, statt sie selbst zu schreiben. Der eingebaute Code ist effizienter.

Geschwindigkeitstest - zwei Arten des for loops über tuples

Ich habe getestet, ob es einen Geschwindigkeitsunterschied zwischen zwei Arten des for loops über eine Liste von tuples gibt:

liste_von_tuples = [(1, 2), (3, 4), (5, 6)]

Es gibt 100.000 tuple, und jeder tuple enthält 2 Zufallszahlen.

Art 1:

for i in liste_von_tuples: 
   res.append(i[1])

Art 2:

for i, j in liste_von_tuples: 
   res.append(j)

Ich hatte erwartet, dass die zweite Art schneller ist, da bei Art 1 eine Zuweisungsoperation von zwei Werten und danach eine Auswahloperation und eine Zuweisungsoperation nötig sind, während bei Art 2 die Auswahloperation wegfällt.

Der Test bestätigte meine Ansicht.

Art 1 braucht bei der Liste mit 100.000 Tuples von je 2 Zufallszahlen zwischen 4% und 12% länger.

Fazit: Bei for loops über tuple, sollte Art 2 verwendet werden:

for i, j in liste_von_tuples: 
   res.append(j)

Die verwendete und ausführlich kommentierte Testdatei ist angehängt.

Anmerkung: Meine Python Tests können jetzt auch mit Mercurial heruntergeladen werden: http://bitbucket.org/ArneBab/python_tests/

Ideen und Patches wären cool :)

Hallo Welt! (PyQt)

Ich habe mein erstes Programm mit PyQt erstellt.

In guter Programmier-Tradition heißt es "Hallo Welt!", und zeigt einfach "Hallo Welt!" an.

Ich habe es allerdings recht ausführlich kommentiert, so dass ich denke, dass es PyQt-Neulingen ein paar interessante Einzelheiten zeigen und Programmier- und Python-Neulingen ein paar einfache erste Einsichten geben kann.

Ich habe es angehängt, stelle den Code aber auch diekt auf diese Seite, denn Python Code ist schön genug, dass ich ihn offen auf die Webseite stellen kann.

-----

#!/bin/env python
# encoding: utf-8

#######################################################
#                                                     #
# Hallo Welt!                                         #
# - Mein Erstes PyQt-Programm mit Kommentaren         #
#                                                     #
#   Copyright (C) 2007, Arne Babenhauserheide, GPL    #
#                                                     #
#   This program is free software; you can            #
# redistribute it and/or modify it under the terms of #
# the GNU General Public License as published by the  #
# Free Software Foundation; either version 2 of the   #
# License, or (at your option) any later version.     #
#                                                     #
# This program is distributed in the hope that it     #
# will be useful, but WITHOUT ANY WARRANTY; without   #
# even the implied warranty of MERCHANTABILITY or     #
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU      #
# General Public License for more details.            #
#                                                     #
# You should have received a copy of the GNU General  #
# Public License along with this program; if not,     #
# write to the Free Software Foundation, Inc., 51     #
# Franklin Street, Fifth Floor, Boston, MA 02110-1301 #
# USA.                                                #
#                                                     #
#######################################################


# Erst holen wir das System-Framework. "sys"
# Qt Programme brauchen von ihm die 
# Kommandozeilenparameter. 

import sys

# Dann die benötigten Qt-Klassen. 
# Erstens das grundlegende Widget für Programme
# QApplication

from qt import QApplication

# und Zweitens einen Knopf, den wir beschriften wollen
# QPushButton

from qt import QPushButton

# und dann noch Signal und Slot, 
# damit ein Druck auf den Knopf
# das Programm beenden kann. 

from qt import SIGNAL, SLOT

# Jetzt können wir uns das Programm app definieren 
# und ihm die Kommandozeilenparameter übergeben: 

app=QApplication(sys.argv)

# Der Knopf ist ähnlich schnell geschrieben. 
# Er erhält den Text "Hallo Welt!\nIch kann 
# (ein bisschen) PyQt!"
# Das \n erzeugt einen Zeilenumbruch. 
# Einfallsreicherweise nennen wir ihn "button". 

button=QPushButton("Hallo Welt!\nIch kann (ein bisschen) PyQt!", None)
# button=QPushButton(u"Hallo traumrose!\nIch liebe Dich!\nKüsst du mich?", None)

# Jetzt machen wir ihn zum Haupt-Widget 
# des Programmes "app", 
# so dass er auf der obersten Ebene liegt: 

app.setMainWidget(button)

# Dann sagen wir ihm, dass er angezeigt werden soll. 

button.show()

# Kurz vor dem Abschluss fügen wir noch 
# als kleine Spielerei 
# etwas Interaktivität hinzu: 
# Das Programm soll sich beenden, 
# wenn der Knopf gedrückt wird. 

# Dafür verbinden wir das Signal "pressed()" 
# des Knopfes "button" 
# mit dem Slot "quit()" des Programmes app. 

app.connect(button, SIGNAL("pressed()"), 
		app, SLOT("quit()"))

# Als letztes führen wir das GUI-Programm aus. 
# Erst hier wird der Knopf wirklich sichtbar. 

app.exec_loop()

# Um das zu testen kannst du das Programm einfach 
# Schritt für Schritt in der Python-Shell ausführen. 

# Das beendet mein erste Programm. 
# Ich hoffe, Du hattest Spaß beim Lesen!

Python Speicherverwaltung

Ich habe einen kleinen Test gemacht, um zu schauen, wie die Speicherverwaltung von Python funktioniert.

Dafür habe ich eine Klasse erzeugt, die eine extrem lange Liste als Attribut hatte, so dass viel Ram verbraucht wurde.

Dann habe ich mehrfach eine Instanz dieser Klasse der gleichen Variable zugewiesen.

Das Ergebnis war, dass höchstens der doppelte Speicherbedarf einer einzelnen Instanz verbraucht wurde.

Außerdem habe ich herausgefunden, dass ein dict mit 3 Millionen unterschiedlichen Schlüsseln, die auf das gleiche Objekt zeigen (None), etwa doppelt so viel Ram braucht wie eine Liste, die diese Schlüssel als Werte hat.

Das Skript zum Testen habe ich angehängt und poste es auch nochmal hier.

Viel Spaß beim selbst mit Python spielen :)

#!/usr/bin/env python
# encoding: utf-8

"""This file tests the memory purging of python by creating an instance of a
class over and over again.

It shows, that the instance is created at only one of two places over and over
again, so the maximum additional memory consumed when replacing an
instance is the size of the instance 

The reason seems to be that the instance is first created and then assigned
to the variable. Only after that, the previous object gets deleted. 

This seems easy to understand, because this behaviour is necessary to allow
for recursive functions where the new value of the variable depends on its
previous value. 

"""

# We want random, so that no optimizing of same objects can be done. 

from random import random


# Now we create a memory hungry class. 

class MemoryHungry(object): 
    """MemoryHungry is a class which just has many attributes which consume 
memory.

For me one instance of MemoryHungry takes about 140Mib with 
number_of_atts=3,000,000 - bab.

When I use a dict where I assign keys with random names to the value None 
(all the same object), this takes about 250MiB per instance. - bab
"""
    def __init__(self, number_of_atts=3000000, mode="list"): 
        if mode == "list": 
            self.liste = [] #: list of random numbers
        elif mode == "dict": 
            self.liste = {} #: dict with random numbers as keys

        # We add random numbers to teh list to make sure, that no memory 
        # usage can be optimized by grouping same objects or similar. 
        for i in range(number_of_atts): 
            self.blah = random() #: temporary random number
            # append self.blah to the list attribute of the class, so it consumes 
            # memory (as object of the list reassigning self.blah doesn't delete the 
            # value/instance of float): 
            if mode == "list": 
                self.liste.append(self.blah)
            if mode == "dict": 
                self.liste[self.blah] = None 
                # None is only one object, so what takes space here are the keys.


# Also we create a class thirsty, which creates a float with the same content 
# over and over again. 

class MemoryThirsty(object): 
    """MemoryThirsty is a class which just has many attributes which consume 
memory.

For me one instance of MemoryThirsty only takes about 70Mib with 
number_of_atts=3,000,000, which is half the amount taken by the same 
number of random numbers -bab.
"""
    def __init__(self, number_of_atts=3000000): 
        self.liste = [] #: List of random numbers

        # We add random numbers to the list to make sure, that no memory 
        # usage can be optimized by grouping same objects or similar. 
        for i in range(number_of_atts): 
            self.blah = 0.111111111111111111111111111111111 #: just a floating point number
            # append self.blah to the list attribute of the class, so it consumes 
            # memory (as object of the list reassigning self.blah doesn't delete the 
            # value/instance of float): 
            self.liste.append(self.blah)



### Self-Test ###

if __name__ == "__main__": 
    # Create a MemoryHungry instance and give it to a variable over and over again.
    print "hunger"
    for i in range(10): 
        # assign an instance of MemoryHungry to the variable hunger
        hunger = MemoryHungry(mode="dict")
        # And print the instance. 
	print hunger, i
        pass
    print "hunger done"
    del hunger
    print "thirst"
    for i in range(10): 
        # assign an instance of MemoryHungry to the variable hunger
        thirsty = MemoryThirsty()
        # And print the instance. 
	print thirsty, i
    del thirsty
    # We're done. Say so. 
    print "done"

Alsa-Gerät in amarok einrichten

Um in Amarok ein Hauptgerät einzurichten, muss es einfach in Einstellungen -> Audio Ausgabe eigetragen werden.

Damit das geht muss das Ausgabe-Modul auf Alsa gestellt und die Änderung angewendet werden.

Ein Eintrag für Soundkarte 1 (also die zweite Soundkarte, da die Liste bei 0 anfängt) sieht im einfachsten Fall so aus:

hw:1

Komplexere Konfigurationen können in einer Mail auf den kde mailinglisten nachgelesen werden:

http://mail.kde.org/pipermail/amarok/2006-October/001619.html

Standardmäßig enthalten die Boxen:
Mono: default
Stereo: default
4 Channel: plug:surround40:0
6 Channel: plug:surround51:0

Die zweite Soundkarte könnte auch mit "plughw:1,0" unter Stereo angesprochen werden.

Ich hoffe, es hilft dir!

(und erspart dir die Stunden an Zeit und Nerven, die ich reingesteckt habe, bis ich die einfache Lösung gefunden hatte. Das Internet ist toll, wenn man weiß, nach was man suchen muss :) ... in meinem Fall: google "amarok alsa device" :) )

ARD muss löschen ⇒ Alle Rezepte runterladen

Nachdem nun die ARD ihre Artikel löschen muss und bereits 80% der Rezepte gelöscht wurden, speichere ich jetzt alle ihre Rezepte auf meinem eigenen Rechner.

Da ich das mit den anderen bisher nicht gemacht habe, nutze ich wget, um das für die noch existierenden nachzuholen. Ich vermute, dass du das auch machen willst, so dass dir die Rezepte, für die du GEZ gezahlt hast, nicht gestohlen werden können.

Deshalb ist hier mein wget-Aufruf:

Einfach in eine shell kopieren (du brauchst dafür wget).

wget -mkE --no-parent http://www.swr.de/buffet/guten-appetit/

Fast das gleiche funktioniert auch bei anderen Seiten, die sie offline nehmen müssen.

Wenn du die Seite nicht vollständig willst, sondern lieber die Druckversion als PDF, kannst du auch etwa 10 PDFs auf der Download-Seite des Rezept-Archivs runterladen.

Aber beeil dich, du weißt nicht, wann sie „dank“ unserer Landespolitiker auch die löschen müssen…

wget -rl1 -kE -A pdf http://www.swr.de/buffet/guten-appetit/-/id=257024/nid=257024/did=307880/xlslkj/index.html

babtools - bashrc

Ich lege mir seit Jahren in meiner bashrc aliase für komplexere Befehle an, und da ich denke, dass einige davon auch anderen Leuten nützlich sein könnten, habe ich mich entschieden meine bashrc zu veröffentlichen.

Vorher habe ich sie etwas aufgeräumt, damit sie auch lesbar ist, wenn man sie nicht selbst geschrieben hat :)

Wenn ihr Tipps und Ideen dafür habt, schreibt sie einfach in's Kommentarfeld, dafür ist das da :)

Die bashrc ist auch im Anhang zum herunterladen.

====== bashrc ======

# /etc/skel/.bashrc:

if test -z "$DBUS_SESSION_BUS_ADDRESS" ; then
eval `dbus-launch --sh-syntax --exit-with-session`
fi


====== /bashrc ======

Endlich frei! - Freier radeonhd Treiber für meine ATI Karte

Ich habe heute mein X auf den freien radeonhd treiber umgestellt, und damit bin ich nun endlich wirklich frei!

Das muss natürlich heißen: Mein Computer nutzt nun nur noch freie Software, nachdem ich endlich die unfreien Graphikkartentreiber rausschmeißen konnte.

Ich hatte leider eine ATI X1300 Karte, die vom alten freien Radeon Treiber nicht unterstützt war.

Update: Der alte freie Radeon treiber unterstützt nun meine Karte in der testing version. Da er aktuell besser Beschleunigung bietet nutze ich zur Zeit also radeon statt radeonhd, aber radeonhd hat dafür den Weg geebnet.

Der neue RadeonHD Treiber unterstützt nun meine Karte, und ich bin glücklich endlich von dem unfreien Treiber weggekommen zu sein.

Der folgende Forenbeitrag hat mir geholfen, alles zum Laufen zu bekommen:

"Basically, I unmasked and emerged xf86-video-radeonhd and set the driver to radeonhd" (ganz unten auf der Seite)
- http://forums.gentoo.org/viewtopic-t-625940-highlight-radeonhd.html

Und der Artikel zum radeonhd Treiber:
- http://forums.gentoo.org/viewtopic-t-606785-highlight-ati+screens.html

Außerdem der passende Eintrag im Gentoo-Wiki:
- http://gentoo-wiki.com/HOWTO_DRI_with_ATi_Open-Source_Drivers

Aber was ich eigentlich nur gemacht habe war:

Meinen Kernel mit Direct Rendering Manager aber ohne Radeo Treiber neu bauen:

Character devices  --->
   /dev/agpgart (AGP Support) 
   Direct Rendering Manager (XFree86 4.1.0 and higher DRI support)

Dann modules.autoload anpassen (ich habe ein nvidia board - Details im Gentoo-Wiki):

vim /etc/modules.autoload.d/kernel-2.6

# babcode: ATI drivers
nvidia-agp
agpart
radeonhd

Die unfreien ATI-treiber rausschmeißen und radeonhd emergen:

emerge -C ati-drivers
echo  "x11-drivers/xf86-video-radeonhd" >> portage-keywords/hardware
emerge x11-drivers/xf86-video-radeonhd

Und am Ende noch die xorg.conf anpassen:
/etc/X11/xorg.conf (*brr* fühlt sich das seltsam an ohne tab-vervollständigung :) )

In Section "Device" muss bei "Driver" "radeonhd" eingetragen werden.
(Ich hatte zwei Abschnitte, in denen ich das machen musste).

Damit habe ich zwar sicher noch nicht die schnellstmögliche EInstellung drin, aber mein Rechner läuft endlich nur noch mit freier Software!

Wenn ihr mehr Leistung rausholen wollt, könnt ihr sicher einige Tipps in den Gentoo Foren und dem Gentoo Wiki finden.

Ich bin Frei!
Yay!

hp photosmart druckt nicht mehr - communication problem: lpr 256

Update: Diese Lösung hat mein Problem kurzfristig gefixt - nach einer Weile hatte ich wieder Probleme. Inzwischen habe ich mein System neu aufgesetzt und er läuft wieder.

Ich habe gerade Stunden damit zugebracht, meinen Drucker endlich wieder zum Laufen zu bringen.

Die Lösung war:

cd /dev/bus/usb
chmod o+w */*