July 2006

Das Archiv

• www

  XHTML 2.0 - New Working Draft

  28.07.06 | Link | 4 Kommentare

  The World Wide Web Consortium (W3C) has published a new Working Draft of XHTML 2.0!

  If you could hardly await seeing the facts, take a look around.

• Programming

  Scope of Variables

  23.07.06 | Link | Kommentieren?

  In diesem Artikel befassen wir uns mit der Sichtbarkeit von Variablen.

  Was ist eigentlich der Scope einer Variablen ?

  Unter Scope versteht man den Bereich der Sichtbarkeit bzw. die Gültigkeit einer Variable im Programmcode.

  Genauer gesagt ist der Gültigkeitsbereich einer Variablen der Programmabschnitt, für den die Variable nutzbar und sichtbar ist.

  Demzufolge ist eine Variable mit kleinem Scope nur in einem kleinen Abschnitt des Programmes bekannt.

  PHP Beispiel einer Variablen mit kleinem Scope
  $loop_index = 0;
  while ( $loop_index < 100 ) :
    ...
    $loop_index++;
  endwhile;

  Die Variable loop_index hat in diesem Beispiel lediglich einen kleinen Gültigkeitsbereich - sie in diesem Fall nur innerhalb des Loops gültig.

  Dagegen ist eine Variable mit großem Scope in vielen Teilen des Programmes bekannt.

  PHP Beispiel einer Variablen mit großem Scope
  $zellen_farbe = ‘#000′;

  # some code
  …

  # table of departments
  $abteilungsleiter_zellenfarbe = $zellen_farbe;
  …

  # some code
  …

  # table of employees
  $sachbearbeiter_zellenfarbe = $zellen_farbe;

  # some code
  …

  In diesem Beispiel hat die Variable zellen_farbe einen großen Gültigkeitsbereich, da sie fast im kompletten Programm verwendet wird.

  Globale vs. lokale Variablen

  In diesem Zusammenhang muss man natürlich die Begriffe globale Varibale und lokale Variable erläutern.

  Globale Variablen sind Variablen, die im gesamten Programm sichtbar und gültig sind.
  Sie benötigen aus diesem Grund einen eindeutigen Namen innerhalb des Programmes.
  Aufgrund der globalen Sichtbarkeit sind diese Variablen sehr bequem zu verwenden.
  Man muss diese nicht beim Aufruf einer Funktion an diese übergeben, sondern kann sie direkt in der Funktion ansprechen.

  Lokale Variablen sind Variablen, auf die man nicht im gesamten Programm zugreifen kann.
  Ist beispielsweise eine Variable innerhalb einer Funktion deklariert, so kann man diese nur innerhalb, jedoch nicht außerhalb, der Funktion ansprechen und benutzen.
  Der Name der Variablen muss in diesem Fall nur innerhalb der Funktion eindeutig sein. In einer anderen Funktion kann es natürlich eine Variable mit dem gleichen Namen geben, da diese ja nur innerhalb der Funktion gültig sind.

  Welche Art von Variable sollte nun genutzt werden ?

  Wie wir festgestellt haben, birgt die Verwendung von globalen Variablen auch ein gewisses Fehlerpotential, denn

  • wenn man eine globale Variable für mehrere Zwecke benutzt
  • wenn man eine lokale Variable mit dem Namen einer globalen Variable verwendet (dann kann es passieren das man den Wert der globalen Variable mit dem Wert der lokalen Varibale überschreibt!)

  kann es zu schwer auffindbaren Fehlern kommen, die den Programmierer zusätzliche Zeit aufgrund der Fehlersuche kosten.

  Aus diesem Grund sollte man globale Variablen nur dann verwenden, wenn es keine andere Möglichkeit gibt.

  Die folgende Abbildung verdeutlicht noch einmal den Unterschied zwischen einer lokalen und einer globalen Variable.
  Gültigkeitsbereich von lokalen und globalen Variablen (Quelle: de.wikipedia.org)

  Live time von Variablen

  Die Live time einer Variablen ist die Lebenszeit der Variablen.
  Sie beginnt mit der ersten Referenz dieser Variable (z.B. x = 0) und endet mit der letzten Anweisung in welcher auf diese Variable referenziert wird.

  PHP Beispiel Live time einer Variablen
  # first reference - begin of live time of the variable zellen_farbe
  $zellen_farbe = ‘#000′;

  # some code
  …

  # second reference
  $abteilungsleiter_zellenfarbe = $zellen_farbe;
  …

  # some code
  …

  # last reference - end of live time of the variable zellen_farbe
  $sachbearbeiter_zellenfarbe = $zellen_farbe;

  # some code
  …

  Wird also eine Variable in Zeile 1 zum ersten Mal referenziert (1.Referenz) und in Zeile 50 zum letzten Mal (letzte Referenz), so hat die Variable eine Lebenzeit von 50 Anweisungen (Statements).

  Ziel für den Programmierer ist es, die Lebenszeit einer Variablen (also die Spanne zwischen der 1. und der letzten Referenz) so kurz wie möglich zu halten.

  Die daraus resultierenden Vorteile liegen auf der Hand:

  • der Programmierer kann die Chancen einer inkorrekten Änderung oder Zuweisung der jeweiligen Variablen minimieren (siehe: Initialisiere die Variable so “nah” wie möglich bei der ersten Verwendung)
  • die Chancen von Initialisierungsfehlern werden minimiert (siehe: Initialisiere namenhafte Konstantenvariablen am Anfang, echte Variablen während des Programmcodes)
  • der Code ist viel besser lesbar
  • nützlich, wenn man eine große Routine in mehrere kleinen Routinen teilen möchte

  Messung der Lebenszeit von Variablen

  Wie bereits erwähnt kann man die Lebenszeit einer Variablen messen, indem man die Differenz zwischen der letzten Referenz und der ersten Referenz der Variable bildet.

  Hier ein Beispiel einer zu langen Lebenszeit von Variablen:

  PHP Beispiel mit zu langen Live times der Variablen
  1  # initialize all variables
  2  $anzahl_noten = 0;
  3  $durchschnittsnote = 0.00;
  4  $berechnung_abgeschlossen = false;
     …
  26 while ( $anzahl_noten < 10 ) :
  27 ...
  28 $anzahl_noten++; # <- *LR*
     ...
  64 while ( !$berechnung_abgeschlossen ) :
      ...
  69  if ( $durchschnittsnote < 0 ) : # <- *LR*
  70    $berechnung_abgeschlossen = true; # <- *LR*

  *LR* - last reference of the variable

  Die Lebenszeiten der einzelnen Variablen sind:
  anzahl_noten -> (Zeile 28 - Zeile 2 + 1) = 27
  durchschnittsnote -> (Zeile 69 - Zeile 3 + 1) = 67
  berechnung_abgeschlossen -> (Zeile 70 - Zeile 4 + 1) = 67

  Durchschnittliche Lebenszeit der Variablen -> (27 + 67 + 67) / 3 = 54

  Hier nun ein weitaus besseres Beispiel mit kurzen Lebenszeiten der Variablen:

  PHP Beispiel mit kurzen Live times der Variablen
     …
  25 $anzahl_noten = 0;
  26 while ( $anzahl_noten < 10 ) :
  27 ...
  28 $anzahl_noten++; # <- *LR*
     ...
  62 $durchschnittsnote = 0.00;
  63 $berechnung_abgeschlossen = false;
  64 while ( !$berechnung_abgeschlossen ) :
      ...
  69  if ( $durchschnittsnote < 0 ) : # <- *LR*
  70    $berechnung_abgeschlossen = true; # <- *LR*

  *LR* - last reference of the variable

  Die Lebenszeiten der einzelnen Variablen sind:
  anzahl_noten -> (Zeile 28 - Zeile 25 + 1) = 4
  durchschnittsnote -> (Zeile 69 - Zeile 62 + 1) = 8
  berechnung_abgeschlossen -> (Zeile 70 - Zeile 63 + 1) = 8

  Durchschnittliche Lebenszeit der Variablen -> (4 + 8 + 8) / 3 = 7

  Wie man gut erkennen kann, wurden in diesem Beispiel die Variablen so nah wie möglich zur ersten Referenz initialisiert (siehe: Initialisiere die Variable so “nah” wie möglich bei der ersten Verwendung).
  Der Unterschied der durchschnittlichen Lebenszeiten der Variablen ist beachtlich:
  54 zu 7!
  Deshalb ist es eindeutig, dass das 2.Beispiel bei weitem das bessere der beiden ist.

  Somit lässt sich auch die These untermauern, dass man globale Variablen, aufgrund der großen Lebenszeiten, wenn möglich vermeiden sollte.

  In a nutshell

  Zusammenfassend, hier nun einige Tipps um die Lebenzeit von Variablen zu verkürzen.

  1 Initialisiere Zählvariablen direkt vor der Schleife

  Wenn man die Zählvariable direkt vor dem Loop initialisiert, hat man sie gleich mit der Schleife im Blickfeld und muss nicht erst lang suchen.
  Wenn der Loop nun geändert wird, denkt man zwangsläufig an eventuelle Anpassungen der Zählvariable, weil sie ja unmittelbar mit dem Loop in Verbindung steht.

  Siehe auch Achte auf Zählvariablen

  2 Initialisiere die Variable erst kurz vor ihrer Verwendung

  Somit kann man sich langes Suchen sparen und weiß sofort wo der Wert zugewiesen wurde.

  Siehe auch Initialisiere die Variable so “nah” wie möglich bei der ersten Verwendung

  3 Beschränke die Sichtbarkeit einer Variable so gut wie möglich

  Es ist bedeutend einfacher, aus einer lokalen Variable eine globale variable zu machen.
  Der umgekehrte Weg kann jedoch, je nach Komplexität des Programmes, immense Schwierigkeiten bereiten.

  Demnach sollte der Programmierer stets bestrebt sein, globale Variablen zu vermeiden und stattdessen, lokale Variablen zu nutzen.

  4 Lagere gruppierte, zusammenhängende Anweisungen in getrennte Routinen aus

  Durch die Trennung in mehrere kleinere Routinen wird das Programm einerseits modularer und andererseits wird der Scope (also die Sichtbarkeit) der Variablen minimiert.

  Ein Programm mit sehr großem Scope (also lange Lebenszeiten der Variablen), ist mitunter einfacher zu schreiben!

  Allerdings sollte ein Programm auch gut lesbar sein!
  Gute Lesbarkeit erreicht man jedoch nicht, wenn jede Routine eines Programmes auf jede Variable im Programm zugreifen kann!

• Programming

  Initializing Variables

  21.07.06 | Link | Kommentieren?

  In diesem Artikel beschäftigen wir uns mit der Initialisierung von Variablen.

  Einleitung

  Vielleicht fragen sich einige von euch, was daran so schwer sein soll - ist doch ganz einfach eine Variable zu initialisieren.
  Die Initialisierung der Variable als Aktion ist ja auch nicht der Sachverhalt, welcher hier besprochen werden soll.
  Viel entscheidender ist in diesem Zusammenhang der Prozess der Initialisierung einer Variable.

  Warum ist eine korrekte Initialisierung von Variablen so wichtig ?

  Ungeeignete Dateninitialisierung ist eine der Hauptprobleme in der Software-Entwicklung.

  Mögliche Fehlerursachen sind:

  • der Variable wurde überhaupt kein Wert zugeweisen
  • der zugewiesen Wert ist nicht mehr aktuell - also mitunter auch nicht länger gültig
  • einem Teil der Variable wurde ein Wert zugeweisen und einem anderen Teil nicht

  Man kann sich also mit einer richtigen Technik zur Initialisierung von Variablen eine Menge Zeit vor dem Debbugger sparen!

  Tipps zur korrekten Initialisierung

  Im folgenden nun einige Tipps zur korrekten Initialisierung von Variablen.

  1 Initialisiere die Variable direkt nach der Deklaration

  Dadurch erstickst du bereits einen Großteil der Initialisierungsfehler im Keim.

  C++ Beispiel einer direkten Initialisierung nach der Deklaration
  float durchschnittsnote = 0.00;

  2 Initialisiere die Variable so “nah” wie möglich bei der ersten Verwendung

  Zu Beginn ein eher schlechtes Beispiel einer Variableninitialisierung:

  Visual Basic Beispiel einer schlechten Variableninitialisierung
  ‘ declare all variables
  Dim anzahl_der_noten As Integer
  Dim durchschnittsnote As Double
  Dim berechnung_abgeschlossen As Boolean

  ‘ initialize all variables
  anzahl_der_noten = 0
  durchschnittsnote = 0.00
  berechnung_abgeschlossen = False
  …

  ‘ code using anzahl_der_noten
  …

  ‘ code using durchschnittsnote
  …

  ‘ code using berechnung_abgeschlossen
  while Not berechnung_abgeschlossen
  …

  Hier kann man gut erkennen, das die Spanne zwischen Deklaration und Initialisierung der Variablen und der ersten Nutzung dieser sehr groß ist.
  Je größer die Spanne ist, umso unübersichtlicher und fehlerbehafteter kann der Code werden.

  Folgendes lässt sich hierzu sagen:

  1. die Variable berechnung_abgeschlossen kann innerhalb der großen Spanne zwischen Initialisierung und erster Verwendung mitunter bereits wieder einen anderen Wert zugewiesen bekommen haben
  2. die gruppierte Initialisierung am Anfang lässt vermuten, dass die Variablen in der gesamten Routine verwendet werden - jedoch wird berechnung_abgeschlossen nur am Ende der Routine genutzt
  3. mitunter wird die Routine, welche die Variable berechnung_abgeschlossen nutzt, in einem Loop ausgeführt und die Variable berechnung_abgeschlossen muss somit immer wieder neu initialisiert werden (was im obigen Beispiel dann nicht möglich ist)

  Hier nun ein weitaus besseres Beispiel:

  Visual Basic Beispiel einer guten Variableninitialisierung
  Dim anzahl_der_noten As Integer
  anzahl_der_noten = 0
  ‘ code using anzahl_der_noten
  …

  Dim durchschnittsnote As Double
  durchschnittsnote = 0.00
  ‘ code using durchschnittsnote
  …

  Dim berechnung_abgeschlossen As Boolean
  berechnung_abgeschlossen = False
  ‘ code using berechnung_abgeschlossen
  while Not berechnung_abgeschlossen
  …

  Dieses Beispiel ist viel übersichtlicher und eindeutig besser lesbar als das erste Beispiel.
  Man muss sich nämlich nicht fragen, wo die verwendete Variable auf einmal herkommt und von welchem Typ sie ist bzw. mit welchem Wert sie vorbelegt ist - man sieht es sofort.

  3 Benutze Final oder Const wann immer es möglich ist

  Wird häufig genutzt bei Klassen-Konstanten, Eingabeparametern oder sonstigen Variablen, die vor dem Überschreiben nach deren Initialisierung geschützt werden sollen.

  4 Achte auf Zählvariablen

  Besonders bei Zählvariablen ist größte Sorgfalt geboten.
  Achte darauf, dass man Zählvariablen (i,j,k,sum) stets neu initialisieren muss, bevor man sie wieder benutzt (sonst wird aus der Summe sum nach dem nächsten Durchlauf sum+sum)

  5 Initialisiere Klassenvariablen im Konstruktor

  Variablen der Klasse sollte im Konstruktor der Klasse initialisiert werden.
  Zugeteilter Speicher im Konstruktor sollte im Destruktor wieder freigegeben werden.

  6 Bestimme der Ort der Reinitialisierung

  Sollte eine verwendete Variable reinitialisiert werden, so muss man prüfen wo die Variable erneut initialisiert werden soll.
  Dies ist wiederum abhängig von der Nutzung der jeweiligen Variable.
  
  Wird die Variable innerhalb eines Loops genutzt, so muss man sie vor dem Loop neu initialisieren.
  Wird sie jedoch zum Austausch von Daten zwischen mehreren Routinen benutzt, so sollte sie auch an der dazugehörigen Stelle in der jeweiligen Routine neu initialisiert werden.

  7 Initialisiere namenhafte Konstantenvariablen am Anfang, echte Variablen während des Programmcodes

  Variablen die Konstanten namenhaft nachbilden sollen, können am Anfang des Programmes initialisiert werden (vielleicht mit einer Initialize-Routine o.ä.).
  Echte Variablen sollten, wie bereits erwähnt, so nah wie nur möglich am Verwendungsort initialisiert werden.
  
  Soll beispielsweise eine Routine am Ende des Programmes nun statt einmal mehrmals aufgerufen werden, werden die Variablen, welche in der Initialize-Routine initialisiert worden sind, nicht mehr neu initialisiert, da diese Routine ja nur am Anfang des Programmes ausgeführt wird.
  Das kann mitunter sehr schwerwiegende Folgen für die weitere Ausführung des Programmes haben und muss vom Programmierer abgefangen werden.

  8 Ignoriere keine Compiler-Warnungen

  Sei dankbar über jede Warnung des Compilers, er habe eine nicht initialisierte Variable gefunden.

  9 Prüfe Eingabewerte auf Plausibilität

  Eingabewerte sollten vor einer Zuweisung einer Plausibilitätsprüfung unterzogen werden, um so bereits unsinnge Werte auszuschließen.

• Programming

  Variables

  21.07.06 | Link | Kommentieren?

  Diese Artikelserie soll ein paar Tipps zur korrekten Nutzung von Variablen in der Software-Entwicklung geben.

  Wenn man den Begriff Variable im Zusammenhang mit Programmierung hört, denkt man sich mitunter “Was gibt es dazu großartiges zu sagen - ist doch ganz einfach”.

  Um jedoch einen guten und vorallem sauberen, gut lesbaren Code zu entwickeln, sollte man sich dennoch an ein paar Richtlinien halten.

  Dieser Artikel soll eine Art Inhaltsverzeichnis für die kommenden Artikel zum Thema Variablen sein.

  Artikel zum Thema “Variablen”

  1. Initialisierung von Variablen
  2. Sichtbarkeit von Variablen

• Programming, streber

  New stable release 0.065 of streber

  11.07.06 | Link | Kommentieren?

  A new stable version of streber released today.

  This release fixes some of the issues of the last development release, adds translation to Slovak and a very cool new theme by Mats Djärf.

  Changelog

  major

  • fixed creating of project templates
  • new theme “webplasten”
  • added slovak translation
  • fixed display of milestones

  Minor

  • fixed visibility of upcomming projects
  • fixed “comment on task added to project”-bug
  • fixed download name of files containing spaces
  • fixed display of effort sum in task-list
  • in wiki texts show completed tasks with line through
  • keep user logged in if IP_-ADDRESS not checked (do not refresh cookie)
  • added reduced header functionality to person lists (http://streber.pixtur.de/index.php?go=taskView&tsk=1220)

  You can download the latest version (0.065) here.

Tino Beirau - Blog

über

Wer Ordnung hat, ist nur zu faul zum

jüngst

• brown bird
• white flower
• Grolsheim - cloudy sky
• Die Odyssee der Dateigröße von Fotos in iPhoto ‘09
• Neues Gewand und Relaunch

wolke