• Der Backup-Vorgang ist durchschaubar bzw. leicht nachvollziehbar, weil es sich um einen gewöhnlichen Packer handelt und nicht um eine spezielle Backup-Software, bei der man so genau gar nicht weiß, wie sie arbeitet (das kann ich persönlich gar nicht leiden).
• RAR-Dateien kann man (im Gegensatz zu den meisten Backup-Containern kommerzieller Backup-Software, bspw. Acronis True Image) nahezu auf jeder Plattform entpacken, weil der Entpack-Algorithmus öffentlich verfügbar ist. Das gilt natürlich auch für ZIP, 7zip und die meisten anderen Archiv-Formate.
• Das RAR-Format unterstützt sogenannte recovery records (Wiederherstellungsinformationen). Kleinere Schäden an der Backup-Datei (Beispiel: ein paar Sektoren auf der Festplatte spielen verrückt) können damit behoben werden.
• Die Verschlüsselung von RAR-Dateien erfolgt – wenn gewünscht – mit AES-128. Dieser Standard gilt als sicher.

Im Folgenden zeige ich mit welchen Einstellungen man WinRAR für Backups optimiert.

Einstellungen: “Allgemein”

1. Ziel-Datei: In welcher Archivdatei sollen die Dateien gesichert werden?
2. Update-Modus: Das Backup-Archiv soll mit den Quelldaten synchronisiert werden. Das bedeutet, dass neue Dateien hinzugefügt, geänderte Dateien erneuert und gelöschte Dateien auch im Backup gelöscht werden. Hierdurch werden außerdem das 2. und alle folgenden Backups stark beschleunigt, weil quasi-inkrementelle Backups gemacht werden.
3. Kompressions-Methode: Damit das Komprimieren nicht zu viel Zeit in Anspruch nimmt stellen wir die Kompression auf eine schwächere aber schnellere Stufe.
4. Authentizitätsinformationen hinzufügen: Fügt bei der Erstellung des Archivs nochmal einige allgemeine Daten wie Archivname etc. in das Archiv ein. Diese werden beim späteren Öffnen des Archivs geprüft, um grobe Manipulationen zu verhindern. Bietet zwar wenig Sicherheit, kostet aber auch nichts.
5. Wiederherstellungs-Informationen hinzufügen: Hier handelt es sich um den oben beschriebenen recovery record. Unter Erweitert kann man dieses Feature genauer konfigurieren.

Einstellungen: “Erweitert”

Einstellungen, die sehr nützlich sind, aber dem persönlichen Gutdünken obliegen, habe ich blau eingerahmt.

Zu den roten Markierungen:

1. Datenströme speichern: Sehr wichtig, wenn NTFS als Dateisystem eingesetzt wird. Einige Applikationen legen in zusätzlichen NTFS-Dateiströmen einige Informationen ab, die nicht zu den Dateiinhalten selbt gehören, aber mit den jeweiligen Dateien verknüpft sind. Es handelt sich quasi um eine Art von Meta-Informationen, die ohne diese Einstellungen verlorengehen würden.
2. Wiederherstellungs-Informationen: Hiermit legt man fest, wie groß der prozentuale Anteil des recovery records am Archiv sein soll. 2-5% halte ich für angemessen. Standard ist übrigens 1%.

Zu den “Volumen”-Einstellungen: Diese sind nur nutzbar, wenn man das Backup-Archiv in mehrere Teilarchive aufsplittet. Dazu muss man eine Volumengröße unter “Allgemein” angeben.
Jedes “Wiederherstellungs-Volumen” kann genau 1 Original-Volumen wiederherstellen, sogar dann, wenn dieses komplett verloren gegangen ist. Angenommen man hat 30 Teil-Archive (“Volumen”) und 3 Wiederherstellungsvolumen, dann dürfen bis zu 3 Volumen verlorengehen bzw. beschädigt werden. Im Zweifel lohnt sich hier ein Blick in die WinRAR-Hilfe.

Einstellungen: “Dateien”

Der wahrscheinlich wichtigste Teil am Backup: Die zu sichernden Dateien bzw. Verzeichnisse müssen ausgewählt werden.

Hier kann man außerdem bestimmte Dateien bzw. Verzeichnisse vom Backup ausschließen. Bei mir gehören zum Beispiel Downloads definitiv zu den ausgeschlossenen Daten. *.tmp sowie *.bak-Dateien brauchen genausowenig gesichert zu werden.

Ebenfalls sehr nützlich ist es, bestimmte Dateien zwar zu sichern, aber dabei von der Kompression auszuschließen. Das macht das Backup dieser Dateien/Dateitypen deutlich schneller. Zum Beispiel macht es wenig Sinn *.rar, *.zip oder *.jpg-Dateien zu komprimieren, weil diese Dateien bereits komprimiert vorliegen. Ein paar weitere Vorschläge für diesen Filter: *.mp3 *.avi *.mpg

Aufpassen muss man bei der Struktur des zu erzeugenden Archivs. Ich spreche mich sehr stark für die Einstellung “Volle Pfade inkl. Laufwerksbuchstaben” aus, damit nicht nur die Daten selbst, sondern auch ihr genauer Ablageort jederzeit wiederherstellbar bzw. nachvollziehbar ist. In der Standardeinstellung gehen diese Informationen verloren und bei vielen Dateien wird das sehr schnell sehr hässlich, weil man nicht mehr unterscheiden kann, woher die Dateien/Ordner im Einzelnen gekommen sind.

Einstellungen: “Backup”

Wie der Name sagt sind diese Einstellungen speziell für Backups vorgesehen.

“Gemeinsam genutzte Dateien öffnen” sorgt dafür, dass WinRAR versucht, auch momentan durch andere Programme geöffnete Dateien zu sichern. Nichtsdestotrotz wird WinRAR das bei vielen Dateien mit einer Fehlermeldung quittieren. Das ist aber völlig normal.

“Archivnamen aus folgender Maske erzeugen” hängt an den Archivnamen eine Zeichenkette an, die dynamisch zum Beispiel aufgrund der aktuellen Kalenderwoche erzeugt wird. In meinem Fall wird “yyyymm” angehängt, also z.B. “201001″. Dadurch wird maximal 1 Monat lang einunddasselbe Archiv genutzt (“RobertBackup201001.rar”). Für den nächsten Monat erzeugt WinRAR automatisch ein neues Archiv (“RobertBackup201002.rar”).
Folgende Zeichen werden in der Maske akzeptiert (aus der WinRAR – Hilfe; dort findet man weitere nützliche Details):

Damit kann man schon eine ganze Menge erreichen. In diesem Punkt steht WinRAR kommerzieller Backup-Software in nichts nach, eher im Gegenteil. Lediglich das Löschen alter Archive geschieht nicht so leicht automatisch, da muss man schon noch selbst Hand anlegen. Aber um ehrlich zu sein lösche ich meine Backups auch viel lieber selbst…

Kommentar hinzufügen

Im letzten Reiter kann man dem Archiv einen Kommentar hinzufügen. Beispiel:

In diesem Backup enthalten:
C:\Users\Robert\
D:\eclipse

Ausgeschlossen:
C:\Users\Robert\Downloads *.tmp *.bak

Backup-Methode: Synchronisation (geänderte/neue Dateien werden hinzugefügt/überschrieben, gelöschte Dateien werden aus dem Archiv gelöscht)

Speichern der Einstellungen als Profil

Nun wäre das ganze ziemlich mühselig, wenn man all diese Einstellungen jedes Mal aufs Neue festlegen müsste. Dafür bietet WinRAR sogenannte Profile an. Unter “Allgemein” kann man seine Einstellungen auf diese Weise für das nächste Mal speichern (siehe Bild auf der rechten Seite).

Nicht vergessen im folgenden Dialog die ersten beiden Haken anzukreuzen! Außerdem empfehle ich einen Haken bei “Verknüpfung auf dem Desktop anlegen”. Diese Verknüpfung sollte man immer mit Administratorrechten ausführen (kann man in den Einstellungen derselben auch dauerhaft festlegen).

Fazit

Backups mit WinRAR sind schnell, klein, übersichtlich, leicht zu konfigurieren und sicher. Mit Hilfe der Einstellung “Archivnamen aus folgender Maske erzeugen” kann man zudem eine automatische Konsolidierung der Backups umsetzen.

Was will man mehr?

Zunächst einmal: Generics ermöglichen mittels formaler Typparamter, dass Klassen (und Funktionen), die bestimmte Dienste zur Verfügung stellen, mit mehreren Datentypen umgehen können.
Wenn wir zum Beispiel zwei beliebige Objekte als “Paar” verwalten wollen, dann benötigen wir eine entsprechende Klasse mit zwei Attributen, einer Möglichkeit die Objekte darin zu speichern und wieder auszulesen.

An sich nichts schweres:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Pair {
    Object obj1, obj2;
    // Das Einspeichern von Objekten ist der Einfachheit halber nur beim Erzeugen des Paares möglich...
    Pair(Object obj1, Object obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    public Object getFirst() {
        return this.obj1;
    }
    public Object getSecond() {
        return this.obj2;
    }
}

Diese Klasse hat aber einen Haken. Beim Einspeichern gehen die Informationen über den Typ der eingespeicherten Objekte verloren. Wenn wir den Typ wiederherstellen wollen müssen wir einen expliziten Cast durchführen. Andernfalls erhalten wir immer nur Objects.

Pair paar = new Pair(new MeinApfel(), new MeinApfel());
MeinApfel apfel = (MeinApfel)paar.getFirst();

Bei Listen ist das Problem noch dramatischer. Ohne Generics muss man bei jeder Leseoperation auf einer Liste explizit casten:

Vector liste = new Vector();
for(int i=0; i<10; i++)
    liste.add(new MeinApfel());
// ...
for(int i=0; i<liste.size(); i++)
    esseApfel((MeinApfel) liste.get(i));

Bei so vielen expliziten Casts riskiert man außerdem ClassCastExceptions, falls das referenzierte Objekt nicht zu dem entsprechenden Typ konvertiert werden kann.

Abhilfe schaffen hier die Generics. Das soll erstmal am Beispiel der obigen Pair-Klasse demonstriert werden, die folgendermaßen generisch gemacht werden kann:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Pair<A,B> {
    A obj1;
    B obj2;
    Pair(A obj1, B obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    public A getFirst() {
        return this.obj1;
    }
    public B getSecond() {
        return this.obj2;
    }
}

A und B sind sogenannte formale Typparameter, die in diesem Fall für beliebige Typen stehen.
Folgendermaßen erzeugen wir jetzt Paare von Integer-Objekten:

// anschaulich wird hier A = Integer und B = Integer gesetzt
Pair<Integer, Integer> paar = new Pair<Integer, Integer>(new Integer(2), new Integer(3));
 
// kein Cast mehr nötig, weil auch die Signatur von getFirst() quasi dynamisch an Integer angepasst wurde
Integer zahl = paar.getFirst();

Dasselbe ist natürlich auch bei Listen möglich, die bei der Einführung der Generics auch gleich generisch gemacht wurden. Bei Listen gibt es im Gegensatz zu dem Pair-Beispiel nur einen formalen Typparameter, der den Typ der gespeicherten Elemente festlegt.

// Eine Liste von Elementen des Typs "MeinApfel" anlegen...
Vector<MeinApfel> liste = new Vector<MeinApfel>();
liste.add(new MeinApfel());
 
// ...
 
// funktioniert problemlos, da die Signatur von get() genau wie getFirst() aus dem ersten Beispiel an den ggb. Typ angepasst wurde
MeinApfel apfel = liste.get(0);

Richtig trickreich wird es, wenn Funktionen, die Listen entgegennehmen, generisch gemacht werden sollen. Angenommen wir wollen eine Funktion schreiben, die eine Liste von Nahrungsmitteln entgegennimmt und ihr Gewicht bestimmt.
In diesem Fall werden sogenannte Wildcards benötigt.

Intuitiv müsste die Funktion folgendermaßen aussehen:

public double wiege(List<Nahrungsmittel> liste) {
    // ...
}

Diese Funktion würde aber entgegen unserer Intuition bspw. keine Liste mit Äpfeln annehmen, obwohl Äpfel in der Klassenhierarchie ganz klar ein Subtyp von Nahrungsmittel darstellen würden (public class Apfel extends Nahrungsmittel).
Es funktioniert deshalb nicht, weil List<Apfel> einfach nicht kompatibel ist zu List<Nahrungsmittel>. Beispiel:

1
2
3

Vector<Nahrungsmittel> liste1 = new Vector<Nahrungsmittel>(); // OK!
Vector<Apfel> liste2 = new Vector<Apfel>(); // OK!
liste1 = liste2; // FEHLER: cannot convert from Vector<Apfel> to Vector<Nahrungsmittel>

Dieser Code wird vom Compiler deshalb nicht akzeptiert, weil man in eine Liste von Äpfeln keine Nahrungsmittel einfügen kann. Wenn liste1 vom Typ List<Nahrungsmittel> auf liste2 vom Typ List<Apfel> verweisen würde, dann würde das bspw. die Signatur von liste1.add(…) verletzen, denn liste1.add(new Nahrungsmittel()) wäre nicht möglich, weil liste1 auf eine Liste von Äpfeln (und nur Äpfel!) zeigen würde. Das meine ich, wenn ich schreibe, dass List<Apfel> nicht kompatibel ist zu List<Nahrungsmittel>.

Das Problem löst man mit besagten Wildcards:

public double wiege(List<? extends Nahrungsmittel> liste) {
    // akzeptiert alle Listen, deren Elemente Nahrungsmittel oder Subtypen davon sind
}

? steht für einen unbekannten Typ. Bekannt ist bei einer List<?> nur, dass – wie bei jeder typ-parametrisierten Liste – die Elemente, die in der Liste gespeichert sind, alle vom selben (unbekannten) Typ sind.
Das “extends Nahrungsmittel” schränkt die möglichen Typen hier aber insofern ein, als dass Nahrungsmittel die “obere Schranke” darstellt. ? darf hier also vom Typ Nahrungsmittel oder ein Subtyp davon sein.

Es gibt auch die Möglichkeit eine untere Schranke zu definieren: List<? super Nahrungsmittel> bzw. allgemein List<? super X>. Erlaubt sind dann Elemente vom Typ X oder Supertypen davon.

Bleiben wir zunächst bei unserer List<? extends Nahrungsmittel>. Wir können zumindest eingeschränkt mit einer solchen Liste arbeiten: Lesen, aber nicht Einfügen. Das Einfügen klappt deshalb nicht, weil der genaue Typ der Liste nicht bekannt ist. Zwar kann man einen Apfel zu einem Nahrungsmittel konvertieren. Aber die Liste enthält ja nicht notwendigerweise Nahrungsmittel. Sie kann genausogut Birnen enthalten – daher darf man in eine solche Liste keine neuen Objekte einfügen.

Im Folgenden eine Tabelle, die die erlaubten Operationen auf einer Liste dokumentiert:

Bleibt nur noch die Frage zu klären, warum man in eine List<? super X> Elemente vom Typ X und Subtypen von X einfügen darf. Bei List<? extends X> ist das schließlich auch nicht möglich. Nunja, bei extends X sind die Elemente der Liste vom Typ X oder Subtypen davon, d.h. spezieller. Bei super X sind die Elemente vom Typ X oder Supertypen von X, d.h. allgemeiner. Daher kann man Objekte vom Typ X oder von einem Subtyp von X nach Belieben in eine solche Liste einfügen, weil man Objekte von einem bestimmten Typ immer zu einem allgemeineren Typ konvertieren kann.
Faustregel: Jeder Apfel ist ein Obst, aber nicht jedes Obst ein Apfel!

Wichtigster Unterschied zur Schule ist, dass an der Universität keine Allgemeinbildung gelehrt wird. Man kann stattdessen einen von vielen vielen vielen Studiengängen wählen. An manchen Universitäten werden mehr Studiengänge angeboten, an anderen weniger. Ich studiere momentan B.Sc. Informatik an der TU Darmstadt. B.Sc. bedeutet Bachelor of Science und ist ungefähr gleichwertig mit einem Vordiplom. Wenn man diesen Abschluss erreicht hat, dann bedeutet dies, dass man das Grundstudium abgeschlossen hat und das Hauptstudium, in welchem man sich i.d.R. weiter spezialisiert, antreten kann.

Jeder Studiengang besteht aus einer bestimmten Anzahl von Semestern – B.Sc. Informatik hat 6 Semester. Jedes Semester ist ein halbes Jahr lang – man unterscheidet zwischen Wintersemester (1. Oktober bis 31. März) und Sommersemester (1. April bis 30. September).

Jedes Semester wiederum besteht aus bestimmten Lehrveranstaltungen. Eine Lehrveranstaltung heißt zum Beispiel “Mathematik I für Inf und WInf” (Inf=Informatiker, WInf = Wirtschaftsinformatiker) und besteht mindestens aus den zugehörigen Vorlesungen, Übungen und Prüfungen. Jede Lehrveranstaltung wird außerdem von einem Professor, dem verschiedene Hilfskräfte zur Seite stehen, geleitet.

In den Vorlesungen, die in sehr großen Hörsälen von dem jeweiligen Professor gehalten werden, wird der Stoff in sehr schnellem Tempo abgehandelt. Meistens muss man daher nach der Vorlesung einiges nacharbeiten, um den Stoff auch wirklich zu verinnerlichen. Die Vorlesungen dauern jeweils 2 Semesterwochenstunden (SWS), von denen jede 45 Minuten lang ist. Generell wird an der Universität vieles in Semesterwochenstunden gemessen. Werden für eine Vorlesung zum Beispiel 4 SWS angeben, so heißt das, dass man in dem Semester jede Woche durchschnittlich (!) 4×45 Minuten Vorlesung hat.
(Die Teilnahme an den Vorlesungen ist nicht verpflichtend, aber ratsam.)

Beim Lernen des Stoffes helfen die Übungen, die von den Veranstaltern angeboten werden. Eine Übung findet meistens einmal pro Woche oder alle 2 Wochen statt und dauert i.d.R. 2×45 Minuten. Da man nicht alle Hörer der Vorlesung in einer einzigen Übung betreuen kann, werden die Studenten verschiedenen Übungsgruppen zugeteilt. Jede Übungsgruppe besteht i.d.R. aus etwa 20-40 Studenten (das ist bei mir so) und wird von einem Tutor geleitet. Die Aufgabe des Tutors ist es, den Studenten zu helfen und ihre Fragen so gut es geht zu beantworten.
Man trifft sich dann schließlich zu bestimmten Zeiten mit seiner Übungsgruppe und dem Tutor in einer Räumlichkeit der Universität und bearbeitet verschiedene Gruppenaufgaben zum Vorlesungsstoff, die jeweils vor der Übung veröffentlicht und von den Studenten ausgedruckt und mitgebracht werden sollen. Bei der Bearbeitung der Aufgaben soll das Gelernte eingeübt werden.
(Die Teilnahme an den Übungen ist aber meistens nicht verpflichtend, aber wie bei den Vorlesungen ratsam.)

Es gibt allerdings nicht nur Gruppenaufgaben, sondern auch Hausaufgaben. Sie werden Hausübungen genannt. Diese Hausübungen sollen am besten alleine bearbeitet werden, damit man sich auch wirklich sicher sein kann, dass man die Aufgaben selbstständig lösen kann. Meistens ist es erlaubt, die Hausübungen auch in (kleinen!) Gruppen zu lösen – dies muss aber explizit angegeben werden und es muss trotzdem jeder Student seine eigene Lösung abgeben.

Die Hausübungen kann man am jeweils nächsten Übungstermin bei seinem Tutor abgeben (Anmerkung: bei manchen Lehrveranstaltungen kann man die Hausübungen auch online abgeben, natürlich besonders häufig in der Informatik und ähnlichen Fächern). Der Tutor wird die Lösungen dann bis zum nächsten Übungstermin korrigieren, ggf. sogar mit Anmerkungen versehen (wie man die Aufgabe z.B. hätte besser lösen können o.ä.).
Wichtig: Bei vielen Lehrveranstaltungen steht es dem Studenten frei, ob er seine Hausübung bearbeitet und abgibt (auch, wenn er es im eigenen Interesse tun sollte).
Bei manchen Lehrveranstaltungen werden die Hausübungen allerdings bewertet. Man nennt dies dann bewertete Hausübungen. Der Veranstalter kann dann zum Beispiel vorschreiben, dass man mindestens 50% der Punkte in den (bewerteten) Hausübungen erreichen muss, um für die Prüfung zugelassen zu werden. Die Bewertung wird von dem jeweiligen Tutor vorgenommen. Die Abgabe der Hausübungen ist bei solchen Lehrveranstaltungen natürlich Pflicht – ansonsten erhält man keine Punkte.

Zusätzlich zu den Vorlesungen und den Übungen gibt es bei manchen Lehrveranstaltungen auch noch Praktika, Seminare und weitere.
Praktika sind zum Beispiel bei “Grundlagen der Informatik I” kleine Softwareprojekte, die ebenfalls benotet werden. Dabei kommt es vor allem darauf an, das Gelernte anzuwenden. Auch die Planung usw. fließen in die Bewertung ein.
Seminare sind, soweit ich das bisher überblicken kann, benotete Vorträge, für die sich Studenten selbstständig etwas tiefer in eine bestimmte Thematik einarbeiten mussten. sind Lehrveranstaltungen kleineren Umfangs (meist über einige Wochen), an deren Ende das Gelernte entweder mit einer Hausarbeit oder einem Vortrag überprüft wird, woraus dann eine Note hervorgeht.

In den Prüfungen (der üblichen Lehrveranstaltungen) stellt sich schließlich heraus, ob die Studenten das nötige Wissen verinnerlicht haben und unter Zeitdruck anwenden können. Manche Prüfungen sind übrigens geteilt in zwei einzelne Klausuren (die dann für das Gesamtergebnis zusammengerechnet werden). Die Prüfungen finden während der Semesterferien statt. Es handelt sich also gar nicht um echte Ferien – es werden lediglich keine Vorlesungen mehr gehalten, daher auch vorlesungsfreie Zeit genannt.
Zu den Prüfungen ist anzumerken, dass die Veranstalter teilweise komplizierte eigene Regelungen vorsehen. So ist es beispielsweise bei manchen Lehrveranstaltungen so, dass überschüssige Punkte aus den bewerteten Hausübungen zur Verbesserung der Prüfungsnote genutzt werden können. Wenn man sich in den entsprechenden Hausübungen gut schlägt, kann man seine Prüfungsnote am Ende also nochmal deutlich verbessern!
Weiterhin ist zu sagen, dass man die Prüfungen in der Regel relativ leicht schaffen sollte, wenn man die Vorlesungen und Übungen regelmäßig besucht und seine Hausübungen macht. Der Stoff ist schwer, aber man bekommt viel Unterstützung bis zur Prüfung.

Wenn man eine Prüfung nicht besteht, muss man sie – wenn möglich – in einem späteren Semester wiederholen oder das Studium abbrechen. Meistens hat man eine begrenzte Anzahl von Versuchen.

Das waren so die wichtigsten Elemente des reinen Studentenlebens.
Während der Vorlesungszeit geht man in die Vorlesungen, besucht die Übungen, macht seine Hausübungen usw. Wie viel Zeit das etwa kostet, kann ich noch nicht genau beschreiben, weil es im 1. Semester natürlich etwas langsamer los geht. Für die zweite Hausübung von Grundlagen der Informatik I habe ich aber immerhin fast 4 Stunden gebraucht. (Ich werde in einigen Wochen, wenn es richtig hart wird, an dieser Stelle einen kleinen Aufwandsvergleich zur Oberstufe einfügen.)
Wenn die Vorlesungen dann vorbei sind, bereitet man sich auf die Klausuren vor. Das schwierigste dabei ist, dass es die meiste Zeit über niemanden gibt, der einen dazu zwingt, zu lernen. Es gibt Menschen, die damit besser umgehen können und es gibt Menschen, die damit eher nicht zurecht kommen – und der Stoff ist wirklich hart.

Alles in allem macht mir persönlich das Studium bisher wirklich Spaß! Das liegt zum einen daran, dass der Stoff wirklich anspruchsvoll ist und man definitiv nicht gelangweilt ist. Zum anderen ist es schlicht und ergreifend so, dass der Anteil dessen, was mich absolut nicht interessiert, sehr gering ist. Diese ganzen Schulfächer, die man ohne Weiteres aus dem Lehrplan streichen könnte, gibt es jetzt nicht mehr.

Als letzter Hinweis sei noch gesagt, dass für Erstsemester (Ersties) von der Universität oder von höhersemestrigen Studenten sogenannte Orientierungsphasen bzw. Einführungswochen angeboten werden. Alles, was in diesem Artikel beschrieben ist und noch viel viel mehr, wird dann innerhalb von 1 Woche o.ä. ausführlich erklärt. Man wird also auf keinen Fall im Regen stehen gelassen.

Normally, to get handouts printed, you switch to the “Handouts” view and print it, but for some reason a few people just get empty pages then. It doesn’t even matter, which operating system you’re using, the problem is platform-independent.

Fortunately, there is at least one good message: The problem seems to be reproducible, as one official bug report, which is more than 2 years old, indicates: http://www.openoffice.org/issues/show_activity.cgi?id=62935

Moreover, there is a workaround (linux only) for those, who really need to get there handouts printed:

• Switch to the standard view (where you edit your slides normally).
• Export the presentation to PDF format.
• Open your console/shell and execute the following command:
  pdfnup –nup 2×2 –orient landscape –frame true –delta “1cm 1cm” –scale 0.9 –outfile $OUTFILE $INFILE

  pdfnup is part of the “PDFjam” package of tools, whose homepage is at http://www.warwick.ac.uk/go/pdfjam.
  $INFILE is the name of your presentation’s PDF file.
  $OUTFILE is the name of the PDF file your handout pages will be saved to.
  Replace landscape by portrait to change the orientation of your handout pages.
  2×2 can be replaced by CxR, where C is the number of columns and R is the number of rows per page.

• Open $OUTFILE with your favorite PDF viewer. These are your handout pages! Hopefully, you can manage to get them printed.

Indeed, this workaround (original source) really produces high-quality handouts (even better than the handouts that OpenOffice produces itself), but it is quite complicated and some options are missing.
Anyway, if you need to get your handouts fast, this can save your life!

Normally, using Lightning in shared Thunderbird profiles isn’t possible, because there is one extension (.xpi) file for windows and another one for linux. For example, using the linux version under windows leads to terrible layout errors.

Information:

A “shared profile” is a profile which is used by more than one platform. E.g. it enables you to manage the same emails, addresses and bookmarks from either a windows or linux OS.

Ssitter wrote some instructions for those who want to solve Lightning’s problem: UnifiedLightning. You just have to make a “combination” of the platforms’ .xpi files.

When looking for such a combined .xpi file to download I haven’t found anything. Therefore I publish my own .xpi file for both windows and linux: lightning-0.7-tb-linux-and-win.xpi

How to install Lightning for both windows and linux in a shared profile

Notice: This article has been written for Thunderbird 2. I am not sure whether it works when using other versions. Anyway, you use this .xpi file on your own risk!

• Start TB and remove the non-unified Lightning extension.
• Restart TB and install the unified Lightning extension.
• Restart again and enjoy!

(Hinweis: In diesem Artikel wird PHP5 verwendet und vorrausgesetzt!)

Mit Smarty und ein paar Tricks ist es im Grunde sehr einfach, ein Projekt mehrsprachig zu gestalten. Dazu liest man alle nötigen Strings aus Sprachdateien aus und fügt sie an den jeweiligen Stellen ein. Freiwillige Übersetzer erstellen dann unterschiedliche Sprachdateien und man kann das Projekt auch in anderen Sprachen veröffentlichen.

Bei Smarty bedient man sich für diesen Zweck eines Prefilters. Ein solcher Prefilter verändert die Templates noch bevor sie von Smarty “kompiliert” werden.

So ist es z.B. möglich, ein Template wie folgt zu gestalten:

<table border="0">
		<tr>
			<td>##user_form_username##</td>
			<td><input type="text" name="user" value="" /></td>
		</tr>
		<tr>
			<td>##user_form_password##</td>
			<td><input type="password" name="pass" value="" /></td>
		</tr>
</table>

Die von Rauten (#) umschlossenen Zeichenketten spezifizieren einen bestimmten Sprach-String, dessen Ersetzung in den jeweiligen Sprachdateien angegeben wird. Eine deutsche Sprachdatei könnte etwa so aussehen:

user_form_username=Benutzername
user_form_password=Password

Der Prefilter sucht also nach Sprachstrings und fügt an ihrer Stelle die entsprechende Ersetzung ein – je nachdem, welche Sprache eingestellt ist (z.B. in einer serverseitigen Konfigurationsdatei oder innerhalb der übermittelten Browserdaten des Clients usw.).

Für diese Funktionalität empfehle ich eine Klasse, die das Auslesen der Sprachdateien übernimmt. Der Einfachheit nenne ich sie “Lang“.

Ich muss aber darauf hinweisen, dass ich diese Klassen aus einem meiner eigenen Projekte entnommen habe. Daher kann es sein, dass ich teilweise vergessen habe, den Code an diesen Artikel anzupassen. Wenn also irgendetwas von “OBST” oder “XDB” dasteht, wisst ihr Bescheid.

Die Klasse Lang:

<?php
    /**
      * @author: Robert Nitsch
      */
    class Lang {
 
        public $lng;
        protected $lng_strings;
 
        /**
          * Lädt alle Sprachstrings aus der entsprechenden Sprachdatei.
          * @param string $lng Die Sprache, die geladen werden soll, als Länderkürzel.
          */
        function load_lng($lng)
        {
            $this->lng = $lng;
 
            /* DIR_ROOT muss außerhalb dieser Datei deklariert werden und muss den Pfad
                 zum Hauptverzeichnis des Webprojekts beinhalten
                 Außerdem setzt diese Klasse eine gewisse Verzeichnisstruktur vorraus... (/include/lng) */
            $path = DIR_ROOT.'/include/lng/'.$lng.'.txt';
            if(file_exists($path))
            {
                $fh = fopen($path, 'r');
                $matches = array();
                while($zeile = fgets($fh))
                {
                    if(preg_match('/^([^;\s]+)\s*=([^;]*).*$/', $zeile, $matches))
                    {
                        $this->lng_strings[$matches[1]] = $matches[2];
                    }
                }
            }
            else
            {
                throw new Exception("language file '$path' doesnt exist");
            }
        }
 
        /**
          * Gibt einen Sprachstring zurück.
          * @param string $name Der Name des Sprachstrings.
          */
        function get($name)
        {
            return $this->lng_strings[$name];
        }
 
    };
 
    /*
     -> singleton pattern
     (immer nur eine einzige Instanz dieser Klasse zulassen;
     Instanz(en) werden ausschließlich über diese Funktion erstellt)
    */
    function getLangInstance($language) {
        static $lang_instance;
 
        if(!is_object($lang_instance)) {
            global $obst;
            $lang_instance = new Lang();
            $lang_instance->load_lng($language);
        }
 
        return $lang_instance;
    }
?>

Die angepasste Smarty-Klasse nenne ich LangSmarty. Dem Konstruktor muss natürlich eine Instanz der Klasse Lang übergeben werden. Alles Weitere steht in den Kommentaren.

<?php
    /**
      * @author: Robert Nitsch
      */
    class LangSmarty extends Smarty {
 
        /**
            * Speichert die Instanz der Klasse Lang ab.
            * @var Lang Instanz der Klasse Lang
            */
        protected $lang;
 
        /**
          * Konstruktor
          * @param Lang $lang Eine Instanz der Klasse Lang, die die jeweiligen Sprachdaten beinhaltet.
          */
        function LangSmarty(Lang &$lang)
        {
            $this->lang = $lang;
 
            // muss an das jeweilige Webprojekt angepasst werden
            $this->template_dir = './template_dir';
            $this->compile_dir = './compile_dir';
            $this->cache_dir = './cache_dir';
 
            // den prefilter registrieren
            $this->register_prefilter(array(&$this, 'translate_prefilter'));
        }
 
        /**
          * Diese sogenannte Callback-Funktion wird für jedes Auftauchen von ##(...)## innerhalb von Templates
          * aufgerufen und gibt die jeweilige Ersetzung zurück.
          * @param string $string Die konkrete Übereinstimmung. Z.B. "##user_form_username##"
          */
        function _translate_callback($string) {
            $string = substr($string[0], 2, strlen($string[0])-4);
            return $this->lang->get($string);
        }
 
        /**
          * Dies ist der Smarty-Prefilter. Er führt die Ersetzung der Sprachstrings ##(...)##
          * durch die Callback-Funktion _translate_callback() durch.
          */
        function translate_prefilter($tpl_source, &$smarty) {
            return preg_replace_callback("/##[^#]*##/", array(&$this, '_translate_callback'), $tpl_source);
        }
 
        /**
          * Jede sprache soll einen eigenen Satz an Compiled- und Cached-Files haben.
          * Dafür wird das jeweilige  Länderkürzel einfach in den Dateinamen dieser Dateien eingebaut.
          */
        function fetch($_smarty_tpl_file, $_smarty_cache_id = null, $_smarty_compile_id = null, $_smarty_display = false) {
 
            $_smarty_compile_id = $this->lang->lng.$_smarty_compile_id;
            $_smarty_cache_id = $_smarty_compile_id;
            return parent::fetch( $_smarty_tpl_file, $_smarty_cache_id, $_smarty_compile_id, $_smarty_display);
        }
 
    }
?>

Anwendung:

<?php
  $lang = getLangInstance('de'); // instanz der Lang-Klasse erstellen
  $smarty = new LangSmarty($lang); // instanz der LangSmarty-Klasse erstellen, dem Konstruktor wird eine Lang-Instanz übergeben
  $smarty->display('startseite.tpl'); // das Template startseite.tpl kompilieren und das Ergebnis dessen Ausführung (ja, bei Smarty werden Templates ausgeführt) an den Client schicken
  // Sprachstrings werden automatisch eingefügt, sofern im Template vorhanden
?>

Das Ganze lässt sich aber noch optimieren. Die Lösung mit den oben gezeigten Sprachdateien ist zwar einfach, aber bei großen Projekten kann es in viel Arbeit ausarten alle Sprachdateien aktuell zu halten. Auch wenn man diese Arbeit an freiwillige Übersetzer delegieren kann, so empfiehlt es sich, das System generell zu verbessern.

Dies kann mit Hilfe von gettext erreicht werden.

Zitat Wikipedia:

GNU gettext ist die GNU-Internationalisierungsbibliothek. Normalerweise wird sie zur Entwicklung von mehrsprachigen Programmen genutzt. Die derzeit aktuelle Version ist 0.16.1.

Und ja, auch in PHP kann man auf gettext zugreifen: Gettext-Funktionen

Dank der objektorientieren Programmierung müssen wir nur die Klasse Lang an gettext anpassen. Das werde ich in diesem Artikel aber nicht mehr bis ins Detail erklären. Letztendlich läuft es darauf hinaus, dass man nur ein paar Zeilen verändert (nicht aber wesentliche Strukturen).

Der größte Aufwand steckt allerdings in der Gewöhnung an gettext. Bevor man auf gettext umsteigt, sollte man sich daher etwas einlesen. Mir hat der Text ONLamp.com — Gettext sehr gefallen…

Code herunterladen

Es macht keinen Sinn, den Code direkt aus dem Beitrag herauszukopieren, da verschiedene Zeichen von WordPress ungünstig umgewandelt werden. Daher hier der Download des ZIP-Archivs mit den Klassen Lang und LangSmarty:

PHP-Smarty-Mehrsprachig.zip herunterladen

Hinweis: Die Dateien sind UTF-8-kodiert. Linux-Benutzer werden damit keine Probleme haben, Windows-Nutzer sollten auf den Notepad++ – Editor zurückgreifen.

Mit Hilfe des Lehrmaterials “Turtle-Grafik und Fraktale Geometrie” (http://miami.uni-muenster.de/servlets/DocumentServlet?id=1522) konnte ich auch recht schnell einsteigen. Die Schilderungen und die Quelltexte sind auf das Modul turtle bezogen und sind somit grundsätzlich plattformunabhängig. Dennoch empfehle ich Python für diese Experimente, denn dort ist das turtle-Modul bereits integriert und lässt sich phänomenal einfach verwenden.

Das turtle-Modul

Das turtle-Modul ist eine Sammlung an Funktionen, mit deren Hilfe sich ein “Malstift” bzw. “turtle” steuern lässt. Mit Anweisungen wie left(), right(), forward() und backward() kann man einfachste Bewegungen koordinieren. Packt man derartige Anweisungen in rekursive Funktionen, so ergibt sich mit etwas Glück ein immerwiederkehrendes selbstähnliches Gebilde – ein Fraktal.

Die Dokumentation des pythoneigenen turtle-Moduls ist hier zu finden:

http://docs.python.org/lib/module-turtle.html

Die Kochkurve

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

# coding=UTF-8
from turtle import *
import time
 
 
def kochkurve(t, s):
    if(t==0):
        # wenn die gewünschte rekursionstiefe (sprich: feinheit der bewegungen) erreich ist,
        # soll das ganze auf dem bildschirm umgesetzt werden
        forward(s)
    else:
        # die bewegungen der "turtle" werden rekursiv verfeinert
        kochkurve(t-1, s/3)
        left(60)
        kochkurve(t-1, s/3)
        left(-120)
        kochkurve(t-1, s/3)
        left(60)
        kochkurve(t-1, s/3)
 
 
# koch'sche schneeflocke, zusammengesetzt aus mehreren kochkurven
kochkurve(3, 100)
left(-90)
color(1,0,0)
kochkurve(3, 100)
left(-90)
color(0,1,0)
kochkurve(3, 100)
left(-90)
color(0,0,1)
kochkurve(3, 100)
 
# die methode done(), die die hauptschleife betritt, ist offenbar nicht verfügbar :-(
time.sleep(10)
done()

Die Rekursionstiefe (t) bestimmt die Feinheit der Bewegungen. Der Parameter s definiert die Gesamtlänge der Kochkurve.

Ich habe die Funktion am Ende mehrfach aufgerufen, sodass eine sogenannte Koch’sche Schneeflocke entsteht. Eine Koch’sche Schneeflockte besteht aus mehreren Kochkurven, die man aneinandergehängt hat. Und hängt man 4 Kochkurven im Winkel von 90° aneinander, so ergibt sich folgendes Gebilde:

Der fraktale Baum

Fraktale Bäume haben mich irgendwie schon immer beschäftigt. Man stelle sich einen Körper vor, von dem etliche Zweige und Äste abgehen. Von jedem Zweig und jedem Ast gehen erneut ebensoviele Zweige und Äste ab – diesmal nur wesentlich kleiner. Und von diesen kleinen Ästen gehen wieder Äste ab … immer wieder … und jedes Mal werden sie kleiner. Ich hatte meinen Spaß daran mir den kleinsten denkbaren Ast vorzustellen. Natürlich hatte dieser Gedankengang nie ein Ende. Aber wenn man jung ist…

Mit dem turtle-Modul lassen sich natürlich auch fraktale Bäume erzeugen.

Z.Bsp. hiermit:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# coding=UTF-8
from turtle import *
import time
 
 
def baum(s,t):
    if(t >= 0):
        forward(s)
        left(30)
        baum(s*0.6, t-1)
        right(75)
        baum(s*0.7, t-1)
        left(45)
        backward(s)
 
 
sety(-100)
baum(100,7)
 
# die methode done(), die die hauptschleife betritt, ist offenbar nicht verfügbar :-(
time.sleep(10)
done()

Mit Hilfe des Parameters t lässt sich auch hier die Rekursionstiefe festlegen.

Der Code ergibt, wenn man ihn mit dem Python-Compiler aufruft, folgendes:

Selbstverständlich lassen sich Winkel und Streckenlängen variieren. In diesem konkreten Fall ist der linke Ast um 30° (nach links), der rechte um 45° (nach rechts) abgewinkelt. Der linke Ast hat die Länge 0,6*s – das entspricht 60% der Länge des Mutterastes. Der rechte Ast hat jeweils die Länge 0,7*s – also 70% der Länge des Mutterastes.

Weitere Anregungen

Fischpopulationen im Lehrerzimmer mit Tkinter (kleine Andeutung am Rande )

Turtle-Grafik und fraktale Geometrie

• Nutzen
• /wp-admin passwortschützen
• Absoluten Serverpfad ermitteln
• Benutzerdatei anlegen
• Passwörter verschlüsseln
• Benutzerdatei fertigstellen
• /wp-include Ordner schützen
• Abschließende Hinweise
• Weblinks

Dieser Eintrag handelt von WordPress. Genauer gesagt geht es darum WordPress mit sogenannten .htaccess-Dateien abzusichern. .htaccess-Dateien können allerlei Regeln beinhalten, die bestimmen wie mit Dateianfragen umgegangen werden soll. Es gibt viele Beispiele, was man mit .htaccess alles anstellen kann, z.B.:

- Verzeichnisse für bestimmte IPs, IP-Bereiche oder für jeden zu sperren
- Verzeichnisse mit einem Passwort schützen (es können mehrere Benutzernamen definiert werden, mit denen man zugreifen darf!)
- alle diese Regeln können natürlich auch auf bestimmte Ordner/Dateien begrenzt werden

Uns geht es aber hauptsächlich darum,

- das /wp-admin Verzeichnis mit einem Passwortschutz zu versehen. Doppelter Schutz!
- das /wp-include Verzeichnis für den Zugriff von außen komplett zu sperren (nur .php-Dateien sollen gesperrt werden)

Nutzen:

Damit kann man einem “bösartigen” Besucher das “Leben” durchaus erschweren. Denn: ohne Zugriff auf den /wp-admin Ordner bekommt man nicht mal den normalen Admin-Login von WordPress zu Gesicht. Falls es also Sicherheitslücken im Loginskript gibt, so ist man aufs Erste geschützt, auch ohne sofort ein Update einspielen zu müssen (was man natürlich trotzdem tun sollte!!). An den Login kommt man ja nur durch einen vorherigen Login heran (.htaccess ist bereits seit vielen Jahren erprobt und gilt als sehr sicher – im Gegensatz zu den meisten PHP-Skripts).
Das /wp-include Verzeichnis ist für den normalen Benutzer sowieso nicht von Bedeutung. Es gibt aber durchaus Techniken, mit denen ein “Hacker” Sicherheitslücken innerhalb der .php-Dateien in diesem Verzeichnis aufspüren und ggf. ausnutzen kann. Wir verbieten aber gleich sofort den gesamten Zugriff und schließen damit weitere Sicherheitslücken aus.

/wp-admin passwortschützen:

Jetzt wollen wir mal loslegen. Zuerst müssen wir das /wp-admin Verzeichnis mit einem Passwort versehen. Dazu erstellen wir eine Datei mit dem Namen .htaccess und folgendem Inhalt:

AuthType Basic
AuthName “WordPress Administration”
AuthUserFile /absoluter/serverpfad/zurbenutzerdatei/.htaccess_wordpress
require valid-user

Diese Datei muss jetzt in das /wp-admin Verzeichnis hochgeladen werden.

Erklärung:
In der ersten Zeile wird der Passwortschutz “eingeleitet”. In der zweiten Zeile wird dem geschützten Bereich ein Name gegeben. Die dritte Zeile ist wichtig! Hier muss der absolute (Server-)Pfad zur Benutzerdatei angegeben werden.

Absoluten Serverpfad ermitteln:

Der absolute Serverpfad kann relativ leicht ermittelt werden. Man muss eine Datei mit dem Namen pfad.php und folgendem Inhalt erstellen, in das WordPress-Verzeichnis hochladen und dann mit dem Browser aufrufen:

<?php echo "Der absolute Pfad zu diesem Verzeichnis ist: ".$_SERVER['DOCUMENT_ROOT']; ?>

Benutzerdatei anlegen:

Die Benutzerdatei sollte man in ein Verzeichnis legen, das nicht über die Domain zugreifbar ist. Am besten wäre das Verzeichnis, das eine Ebene über der WordPress-Installation liegt. Noch besser wäre das “allerhöchste” Verzeichnis.

Die Benutzerdatei beinhaltet alle Benutzer mit den dazugehörigen Passwörtern. Das Schema für ihren Inhalt lautet folgendermaßen:

benutzername:passwort
hans:nadine1987
joerg:petra1976

(Die Passwörter, die hier beispielhaft gezeigt werden, sind natürlich keine Musterpasswörter. Sie sind weit davon entfernt, sicher zu sein.)

Also pro Zeile ein Benutzer. Benutzer und Passwort werden durch einen Doppelpunkt getrennt.

Passwörter verschlüsseln:

Es fällt außerdem sofort auf, dass die Passwörter hier im Klartext lesbar sind. Gelingt es einem Hacker doch einmal, den Webspace oder den ganzen Server zu hacken, so wird er auch an diese Passwörter gelangen. Das kann man jedoch mit einer sogenannten Einweg-Verschlüsselung unterbinden.

Dazu benötigen wir noch ein Skript mit dem Namen crypt.php und diesem Inhalt:

<?php
    if(!empty($_GET['text']))
    {
        $text=$_GET['text'];
 
        echo 'crypt('.htmlspecialchars($text).') = '.crypt($_GET['text']);
    }
    else
    {
        echo 'This script encrypts strings with the crypt()-function. e.g.: "crypt.php?text=<thestringyouwanttoencrypt>"';
    }
 
    echo '&copy; www.robertnitsch.de';
?>

Dieses Skript kann dann ebenfalls auf den Webspace hochgeladen und über den Browser aufgerufen werden. Zum Beispiel wird http://www.domain.tld/wordpress/crypt.php?text=test den verschlüsselten Wert von “test” berechnen. Dieser sieht zum Beispiel so aus:

$1$Udvw2Yfc$XGUZ6EZFvTC/.9r9.99yX1

Offensichtlich ist das ganz schönes Kauderwelsch. Diese Verschlüsselung kann man auch nicht rückgängig machen.

Wir tragen die verschlüsselten Passwörter genauso ein wie die nicht verschlüsselten, z.B.:

test-user:$1$Udvw2Yfc$XGUZ6EZFvTC/.9r9.99yX1

Auf diese Weise ist auch unsere Benutzerdatei einigermaßen sicher.
Hinweis:
Das Mischen von verschlüsselten und nicht verschlüsselten Passwörtern in derselben Benutzerdatei ist nicht möglich. Entweder es sind alle Passwörter verschlüsselt oder gar keines.

Benutzerdatei fertigstellen:

Die Benutzerdatei muss jetzt noch angelegt werden – wir waren ja wegen der Verschlüsselung noch nicht soweit. Der Dateiname sollte .htaccess_wordpress sein. Wie bereits beschrieben müssen die Benutzernamen und jeweils mit einem Doppelpunkt davon getrennt die Passwörter eingetragen werden. Unbedingt vorher mit crypt verschlüsseln (wie oben beschrieben)! Der absolute Pfad zu der Benutzerdatei musst jetzt noch in der .htaccess-Datei eingetragen werden – falls noch nicht geschehen. Ggf. müssen wir die .htaccess-Datei neu hochladen, damit die Änderung des absoluten Pfades überhaupt wirksam werden kann.

Ab jetzt sollte bei jedem Zugriff auf das /wp-admin Verzeichnis eine Passwortabfrage erscheinen. Wenn alles klappt, dann fahren wir jetzt mit dem Absichern des /wp-include Verzeichnisses fort.

/wp-include Ordner schützen:

Wir erstellen eine weitere Datei “.htaccess” mit dem folgenden Inhalt:

# alle PHP-Dateien fuer den Zugriff von außen sperren
<FilesMatch \.php$>
Order deny,allow
deny from all
</FilesMatch>
 
# tinymce (der what-you-see-is-what-you-get-editor beim schreiben von eintraegen)
# muss zugaenglich sein
<FilesMatch ^tiny_mce>
allow from all
</FilesMatch>
<FilesMatch ^wp\-mce>
allow from all
</FilesMatch>

Wir speichern diese Datei im /wp-include Verzeichnis. Danach ist auch dieses Verzeichnis sicher und wir sind eigentlich fertig.

Abschließende Hinweise:

Bei manchen Anbietern sind diverse Funktionen von .htaccess nicht verfügbar oder gesperrt. In diesem Fall wird ein “Internal Server Error” mit dem Fehlercode 500 auftreten.
Wenn Syntaxfehler oder ähnliche Fehler in den .htaccess-Dateien vorhanden sind, dann wird beim Zugriff auf das entsprechende Verzeichnis bzw. auf die entsprechende Datei ebenfalls ein “Internal Server Error” mit dem Fehlercode 500 auftreten.
Falls unerwartete Probleme auftreten könnt ihr gerne die Kommentar-Funktion nutzen und somit Hilfe einholen.

Wenn etwas partout nicht funktionieren will kann die .htaccess-Datei problemlos wieder vom Webspace entfernt werden. Die Regeln werden damit sofort außer Kraft gesetzt. (Möglicherweise müsst ihr noch euren Browsercache leeren!)

Weblinks:

SelfHTML: .htaccess – Server-Reaktionen kontrollieren
PC-Projekt: .htaccess – Dateien einsetzen
SoftwareGuide: .htaccess und Mod-Rewrite für CMS und Blog

UPDATE: Besagtes Forum ist mittlerweile geschlossen und der Link deswegen nicht mehr gültig.

Das Tutorial behandelt folgende Themen:

- Verzeichnis komplett sperren
- Passwortschutz
- Regeln auf einzelne Dateien beschränken
- Eigene Fehlerseiten

Ich bin mir sicher, dass das für den einen oder anderen interessant sein könnte.