Valles Blog

PHP-Klasse zum Lesen und Schreiben von INIs

Valle — Wed, 26 Nov 2008 22:22:12 +0000

Hello World. Braucht jemand eine PHP-Klasse zum Lesen und Schreiben von Ini-Dateien? Habe heute mal eine geschrieben, da ich diese wahrscheinlich demnächst mal benötigen werde. Die Datei hat knapp über 300 Zeilen und ist gut Dokumentiert. Ich habe sie mal hochgeladen, vielleicht braucht das jemand. Read/write PHP Ini-class (3.19 KB)

Gentoo, Server und Updates

Valle — Tue, 25 Nov 2008 19:42:50 +0000

Ich denke jeder kann mich verstehen, dass ich mich lieber gerne selbst davon überzeuge, was das Richtige ist und was nicht. Das gilt natürlich auch für Gentoo auf Servern. Ich zitiere da mal einen kleinen Satz aus dem Chat, der erst vor wenigen Tagen von Marcel geschrieben wurde.

marcel: Bei Gentoo ist nach einem Update erstmal das halbe System kaputt

Gestern Abend habe ich dann das erste Gentoo-Update auf meinem Root-Server gemacht. Jetzt mal ganz davon abgesehen, dass ich wirklich überrascht war, dass das Update auf diesem nichtmal einem Monat altem Server über 3 Stunden gedauert hat, war es doch fast ein Update, wie es im Buche steht. Gut, es kann schlimmer kommen, aber immerhin gehen alle meine Python-Scripte nicht mehr. Das kann schon ganzschön ärgerlich sein, denn das waren nicht wenige. Jetzt schlage ich mich gerade mit dem Programm “python-updater” rum, welches mir hier wegen irgendwelchen amd64-Keywords ein Ohr kaut.

Tja, was lernen wir wohl daraus? Nächstes mal auf jeden Fall wieder Debian. apt-get update && apt-get upgrade, 20 Sekunden warten und alle Updates sind gemacht. Wenn ich es mir da recht überlege, sind mir die Vorteile von Gentoo dann doch egal. Ich denke allerdings auch, dass ich es mal probiert haben muss. Auch wenn jeder sagt, dass Gentoo nicht das Richtige sei, ist es doch besser für mich, es mal am eigenen Leib erlebt zu haben. Aus Fehlern lernt man eben doch am besten.

Update: So, Problem behoben. Einfach entsprechendes Paket in /etc/portage/package.keywords eintragen. Trifft sich gut, denn jetzt kommt Dr. House auf RTL.

Tag der offenen Tür

Valle — Sat, 22 Nov 2008 12:54:52 +0000

Ich komme gerade aus der Schule (Ja richtig, es ist Samstag)… Heute war Tag der offenen Tür bei uns. Da ist für jeden Schüler jeder Klassenstufe Unterricht. Zwar haben wir nur 4 Stunden und auch nur verkürzte Stunden mit wesentlich längeren Pausen, aber trotzdem beginnt die Schule wie normal um 7:40 Uhr. Grausam sowas; das hat mir das ganze Wochenende verdorben. Und das Schlimmste ist ja, dass der Ausgleichstag (Der Wochentag an dem wir dann frei haben, weil wir ja heute in der Schule waren) während meines Praktikums sein wird. Das heißt dann natürlich, dass wir trotzdem zum Praktikum gehen müssen. Ehrlich gesagt will ich ja auch keinen Tag des Praktikums versäumen. Aber trotzdem sollten wir wie jede andere Klassenstufe einen Ausgleichstag haben. Sowas ist doch dämlich. Da frage ich mich doch, wo das Problem dabei liegt, diesen Ausgleichstag einfach mal zu verschieben. Das kann doch nicht sein, dass die gesamte 9. Klassenstufe um einen Tag verarscht wird - und das schon seit Jahren! Ich habe mich mal als Klassensprecher bei unserem Schulsprecher beschwert. Vielleicht kann er ja ein Wort beim Schulleiter einlegen. Sowas ist doch nicht ok, oder?

Dr. House Spielkarten

Valle — Tue, 18 Nov 2008 21:12:22 +0000

Auch wenn ich die Themen, die meine Kunstlehrerin bisher behandelte nicht besonders prickelnd fand, muss ich doch ausnahmsweise mal gestehen, dass unser aktuelles Thema cool ist. Unsere Aufgabe ist es, Spielkarten zu einem uns beliebigen Thema zu gestalten. Eigentlich sollten wir zu unseren Idolen Spielkarten machen, aber wer hat heutzutage schon Idole, gibt diese offen zu und bringt sie auf eine Spielkarte? Letztlich ist es ja egal, ich habe auf jeden Fall Dr. House ausgesucht. Ob das jetzt mein Idol ist oder nicht, kann man bestreiten. Es gibt auf jeden Fall einige Dinge, auf die ich bei ihm nicht neidisch bin.

Ok, jetzt mal zu dem, was ich eigentlich sagen wollte. Habe heute den ganzen Abend daran gesessen, mal einen Prototyp an Karten zu entwerfen. Ist noch nicht so toll, wie ich das vielleicht erwartet habe, aber auf jeden Fall mal ein Anfang. Wir haben für den Buben ein Bild von Foremen, für die Dame ein Bild von Cameron, für den König natürlich House und für das Ass Cuddy genommen. Die habe ich aus einigen Bildern ausgeschnitten, gespiegelt und *zack* - schon sah das aus wie Spielkarten. Da wir nur eine Farbe (Bekannt als Pik, Herz, Karo und Kreuz) machen müssen, haben wir einen Gehstock genommen. Auch eine Rückseite für die Karten ist schon fertig. Da waren wir wohl aber weniger kreativ, da wir einfach aus einer Folge aus dem Intro ein Bild genommen haben. Was jetzt noch fehlt ist ein Hintergrund auf der Vorderseite. Also der Teil hinter dem Bild von z.B. Dr. House und den Gehstöcken. Eine Idee haben wir aber auch da schon. Wieder ein Teil aus dem Intro.

Tja, mal sehen was die nächsten Tage dabei so rauskommt. Ich werde dann bei Gelegenheit natürlich auch ein paar Fotos vom Fertigen und auch dazugehörige PNGs veröffentlichen.

Collectd und rrdtool

Valle — Wed, 12 Nov 2008 20:03:16 +0000

Endlich habe ich mal ein schönes Programm zum Überwachen der Performance eines Computers gefunden. Das Programm nennt sich collectd. Der Collectd selbst, speichert nur die Daten in regelmäßigen Abständen (Ich glabe es sind 15 Sekunden per default) in mehrere Dateien. Diese Dateien sind im so genannten Round Robin Database-Format. Mit Hilfe des Prorgamms rrdtool kannn man dann relativ einfach eine graphische Darstellung dieser Daten erstellen. Das rrdtool in Aktion kann man hier sehen. Dazu mal ein kleiner Beispiel-Code, der mir einen Graphen über den Verlauf des Load-Averages der letzten 24 Stunden erstellt.

Graph eines Load-Average der letzten 24h

rrdtool graph "/var/www/user/de/dev/htdocs/dev/rrd/load.png" –start -24h –en
–title "load average - last 24h" \
DEF:shortterm=/var/lib/collectd/load.rrd:shortterm:AVERAGE \
DEF:midterm=/var/lib/collectd/load.rrd:midterm:AVERAGE \
DEF:longterm=/var/lib/collectd/load.rrd:longterm:AVERAGE \
LINE1:shortterm#00CC00:"last minute" \
LINE1:midterm#FF0000:"last five minutes" \
LINE1:longterm#0000FF:"last fifteen minutes"

Man kann jetzt damit also recht detailiert seine Graphen erstellen lassen. Ich habe mir dazu gleich ein ganzes Shell-Script geschrieben, dem ich einen Parameter mitgebe, der angibt, von welchem Zeitpunkt an bis jetzt der Graph erstellt werden soll. Das Script könnt ihr euch (mit einer PHP-Datei zur Anzeige auf einem Webserver) nach Bedarf gerne einmal runterladen. Collectd And Rrdtool (1.54 KB)

Die perfekte IDE?

Valle — Sun, 02 Nov 2008 20:46:30 +0000

Es war mal wieder Zeit, mir eine gescheite IDE zu suchen. Jetzt, wo meine Projekte größeren Umfang annehmen und ein normaler Editor nicht mehr reicht (zumindest wenn man trotzdem komfortabel arbeiten will). Die Suche war echt lang. Viele IDEs haben viele tolle Features, aber eben auch Bugs oder fehlende Features, auf die ich nicht verzichten kann. Jetzt habe ich mich aber vorerst mal entschieden.

And the winner is… Eclipse. Naja, wen wundert’s. Eclipse gehört wohl zu den größten, besten und bekanntesten IDEs. Alles, was ich mir so vorgestellt habe (Projekt Manager, SVN integration, Outline) ist da drin und wartet nun noch darauf von mir getestet zu werden. Ich habe mich den heutigen Nachmittag zwar schon recht gut eingearbeitet, aber Eclipse ist so groß, dass ich wohl nichtmal 10% aller Funktionen testen konnte. Ich will mal einen kleinen Screenshot zeigen, damit man sich unter Eclipse was vorstellen kann.

Eclipse IDE

[III] The Game Of Life

Valle — Sat, 25 Oct 2008 11:42:37 +0000

Irgendwie geht mir das nicht aus dem Kopf. Jetzt war mit Python zu langsam und ich habe mich seit meinem letzten Eintrag mit C++ beschäftigt. Zumindest was die Geschwindigkeit angeht, kann ich mich jetzt überhaupt nicht mehr beschweren.

Ich habe Borlands / Codegears Turbo C++ verwendet. Die grafische Oberfläche ist demnach auch mit der VCL gemacht. Irgendwie bereue ich diesen Schritt. Ich muss euch jetzt leider 2 DLLs mitliefern. Das gesamte Paket ist 1,38MB groß. ZIP-gepackt zum Glück nur noch 625kB. Ich werde wohl irgendwann mal eine andere Oberfläche benutzen. Kann doch nicht sein, dass ich für so ein bisschen Code gleich 1,38MB brauche.

Naja, mal zu den Dingen die das Teil momentan kann. Man kann das Spielfeld in Größe und Anzeige bearbeiten. Außerdem (im Gegensatz zur alten Konsolen Version) kann man die Felder des Spielfelds durch einfache Links- und Rechtsklicks bearbeiten. Man hat sogar die Möglichkeit das Spielfeld in eine Datei abzuspeichern und natürlich auch wieder zu laden. Außerdem sind noch ein paar Extras dabei, die einem die Bedienung erleichtern. Den Source-Code werde ich später einmal veröffentlichen.

Ihr könnt euch das Programm ja gerne mal anschauen. Ich denke ich werde daran noch weiter arbeiten, denn irgendwie macht mir das Spaß. Besonders das erwähnte Thema mit der Oberfläche will ich noch ändern. Vielleicht hinterlässt der ein oder andere ja mal ein wenig Kritik in Form eines Kommentars hier. Download: The Game Of Life (625.18 KB)

[II] The Game Of Life

Valle — Mon, 20 Oct 2008 21:04:30 +0000

So, ich habe das Ding jetzt von der Geschwindigkeit etwa verdreifacht. Außerdem noch ein wenig aufgeräumt und den Debug-Code entfernt. Noch ein paar Kommentare und eine Priese Dokumentation dazu und fertig ist’s. Wer sich mein Game Of Life gerne mal anschauen möchte hat hiermit die Gelegenheit. Downloadlink. Oder einfach auf “more” klicken.

#!/usr/bin/python
# Valentin Voigt
import os
import sys
F_DEAD = 0 # Dead cell
F_ALIVE = 1 # Living cell
class GameOfLife:
field = []
renderer = None
generation = 0
def __init__(self, width, height, renderer):
"""Initializes the GameOfLife object.
Width describes the number of cells on the x-axis, height describes
the number of cells on the y-axis. Renderer must be callable. It takes
one argument with the two-dimensional game field."""
self.field = [[F_DEAD for i in range(width)] for i in range(height)]
self.width = width
self.height = height
self.renderer = renderer
def alive_neighbours(self, x, y):
"""Returns the number of living cells around the given cell."""
count = 0
# Some time ago I put that annoying "if"s into some functions called
# "cell_exists" and "if_alive_return_one". So the following part was
# very easy with just 8 lines similar to this one:
# count += if_alive_return_one(x+1, y+1)
# But because this was to slowly I had to put these "if"s here. Now
# the code works a bit faster, although it doesn't look very
# professional anymore.
if y-1 < self.height and y-1 >= 0 and x-1 < self.width and x-1 >= 0:
if self.field[y-1][x-1] == F_ALIVE:
count += 1
if y-1 < self.height and y-1 >= 0 and x < self.width and x >= 0:
if self.field[y-1][x] == F_ALIVE:
count += 1
if y-1 < self.height and y-1 >= 0 and x+1 < self.width and x+1 >= 0:
if self.field[y-1][x+1] == F_ALIVE:
count += 1
if y < self.height and y >= 0 and x-1 < self.width and x-1 >= 0:
if self.field[y][x-1] == F_ALIVE:
count += 1
if y < self.height and y >= 0 and x+1 < self.width and x+1 >= 0:
if self.field[y][x+1] == F_ALIVE:
count += 1
if y+1 < self.height and y+1 >= 0 and x-1 < self.width and x-1 >= 0:
if self.field[y+1][x-1] == F_ALIVE:
count += 1
if y+1 < self.height and y+1 >= 0 and x < self.width and x >= 0:
if self.field[y+1][x] == F_ALIVE:
count += 1
if y+1 < self.height and y+1 >= 0 and x+1 < self.width and x+1 >= 0:
if self.field[y+1][x+1] == F_ALIVE:
count += 1
return count
def activate(self, x, y):
"""Marks the specified cells as alive"""
self.field[y][x] = F_ALIVE
def activate_list(self, cells):
"""Marks the specified list of cells as alive.
Takes a list of lists with two elemts. Example:
activate_list([ (0,1), (2,3), (9,2) ])"""
for cell in cells:
self.activate(cell[0], cell[1])
def tick(self):
"""Calculate the next generation."""
# Initialises a new field with only dead cells. They'll be
# overwritten in the following lines. Before I used [].append to
# create the new field. But this was too slowly, too…
new_field = [[F_DEAD for i in range(self.width)] for j in range(self.height)]
y = 0
for row in self.field:
x = 0
for cell in row:
if cell == F_DEAD:
if self.alive_neighbours(x, y) == 3:
new_field[y][x] = F_ALIVE
else:
new_field[y][x] = F_DEAD
elif cell == F_ALIVE:
n = self.alive_neighbours(x, y)
if n < 2:
new_field[y][x] = F_DEAD
elif n > 3:
new_field[y][x] = F_DEAD
else:
new_field[y][x] = F_ALIVE
x += 1
y += 1
self.field = new_field
self.generation += 1
def render(self):
"""Calls the render function."""
# Reminds me on some of my friends.
# They often make others do their jobs.
self.renderer(self.field)
def ConsoleRenderer(field):
"""Simplest way I found for drawing the game field."""
# Clear screen
if os.name == "nt":
os.system("cls")
elif os.name == "posix":
os.system("clear")
else:
for i in range(0, 100):
print ""
# Print field
for row in field:
for cell in row:
sys.stdout.write("X" if cell == F_ALIVE else " ")
print
print
def start_example():
game = GameOfLife(79, 25, ConsoleRenderer)
game.activate_list([ (50, 16), (51, 16), (51, 17), (51, 15), (52, 15) ])
try:
while True:
game.tick()
game.render()
except KeyboardInterrupt:
pass
if __name__ == "__main__":
start_example()

The Game Of Life

Valle — Sun, 19 Oct 2008 19:42:53 +0000

Heute bin ich auf das “Game Of Life” gestoßen. Auf den ersten Blick langweilig, ist das eigentlich eine total lustige Spielerei. Das Spiel hat ganz einfache Regeln. Es ist aufgebaut wie eine Art Schachfeld. Also ein 2-dimensionales Array. Jedes dieser Felder kann entweder tot oder lebendig sein. Tote und lebendige Felder unterscheidet man ganz einfach durch ihr aussehen. Nun verändert sich bei jedem Durchgang (Generation genannt) das Spielfeld mit Hilfe von ganz einfachen Regeln. Hat eine tote zelle genau 3 lebende Nachbarn, so wird das tote zu einem lebendem Feld. Hat eine lebende Zelle weniger als 2 lebende Nachbarn, so stirbt sie. Hat eine lebende Zelle genau 2 oder 3 Nachbarn bleibt sie lebendig. Hat eine lebende Zelle mehr als 3 lebende Nachbarn, so stirbt sie.

Nun kann man bei diesem Spiel sehr lustige Figuren beobachten, wenn man einfach mal einige beliebige (möglichst nah beieinander liegende) Zellen belebt. So können dabei Animationen entstehen und so lange weitergehen, bis alle Zellen wieder tot sind. Es kann aber auch passieren, dass das ganze in ein totales Chaos verfällt und selbst mach 1000en von Generationen immer noch alles drunter und drüber geht.

Aus reiner Langeweile und aus Interesse wie leicht sowas denn zu programmieren sei, habe ich mal mein eigenes Game of Life programmiert. Es ist in Python geschrieben und gibt seine Zellen bisher leider nur über die Konsole aus. Dazu ist es momentan auch noch sehr langsam, kann also bei mir nur so ca. 88 Generationen in 5 Sekunden berechnen. Ich werde es die nächsten Tage mal ein wenig optmimieren und dann auch hier mal reinstellen. Jetzt erstmal ein wenig ASCII-Art.

                    XX                              X              X      XX
                   X  X                            X X            X X   X XX
                    XX                             XX             X X  XXXXX
                                                                   X       X X
                                        XX                                 X  X
                                       X  X                                 XX
                                        XX
                                    XX                X
                    X               X X              X X
                    X               X                 XX                  XXX
                    X                                                    X   X
                                                            XX  XXXXX    X   X
                                                              XXX    X   X   X
                                                                XX XX     XXX
                                                            X     XX
                                                             X   XX
                             XX       XX                      X   X
                             XX       XX

Happy Birthday!

Valle — Wed, 15 Oct 2008 21:33:59 +0000

Ich habe es jetzt geschafft: mein erstes Projekt hat sich ein Jahr lang gehalten. Ich rede von meinem Freehoster iBitLive, den ich zusammen mit einem Freund “benefix” Anfang letzen Jahres geplant hatte. Schnell fanden sich 3 Coder (“muffin”, “massai” und “ProggerHouse“), mit denen wir ruck-zuck das Projekt programmierten. Ja. Und nun hat es sich schon ein Jahr lang gehalten. Hoffentlich hält es auch noch die nächsten Jahre. Ich für meinen Teil bin jedenfalls zuversichtlich.