Es hat mal wieder gedauert, doch nun will ich den Blog mal mit Leben füllen. Ein neuer Kern braucht auch eine neue Hülle, also habe ich auch direkt ein neues Theme aufgesetzt. Ich hoffe man liest sich hier bald wieder!

Nach Singleton, Memento und Prototype folgt auch schon der nächste Part der Design Patterns: Die Fassade. Sie ist das erste Entwurfsmuster aus dem Bereich der Structural Patterns (Strukturmuster) und dient als einheitliche und vereinfachte Schnittstellen zu einer beliebigen Menge von Schnittstellen eines Untersystems (Subsystems).

Die Fassade sollte also immer dann genutzt werden, wenn ein Untersystem viele Klassen enthält, die aber einzeln selten bzw. garnicht verwendet werden. Statt nun für eine gewisse Funktionalität sehr viele kleine Klassen ansprechen zu müssen, verwendet man eine Fassade, die diese Klassen vereint und Funktionalitäten weiter deligiert. Somit kann eine Fassade die Komplexität einer Implementierung erheblich senken, da das benutzte Untersystem nicht direkt sichtbar ist.

Um die Fassade korrekt zu implementieren benötigen wir als allererstes Subklassen. Diese Klassen enthalten jeweils Teil-Strukturen unserer Fassade, hier am Beispiel eines Kunden. Ein Kunde hat bei einer Bank ein Konto, ein Darlehen und eventuell eine Kreditkarte. Nun möchte er eine Hypothek abschließen. Dazu müssen wir prüfen, ob der Kunde kreditwürdig für eine solche Hypothek ist. Zuerst erstellen wir also unseren Kunden. Dazu dient folgende, sehr vereinfachte Klasse:

class Kunde
{
    public string Name { get; set; }
}

Diese dient nur der Veranschaulichung, denn die wichtigen Subklassen erstellen wir jetzt. Dazu gehören die Klassen Konto, Darlehen und Kreditkarte, welche später in der Fassade vereint werden:

class Konto
{
    public bool HatGenugGuthaben(Kunde k, int betrag)
    {
        Console.WriteLine(string.Format("Prüfe Guthaben für Kunde {0} {1}", k.Name));
        return true;
    }
}
 
class Darlehen
{
    public bool HatDarlehen(Kunde k)
    {
        Console.WriteLine(string.Format("Prüfe Darlehen für Kunde {0} {1}", k.Name));
        return false;
    }
}
 
class Kreditkarte
{
    public bool HatNichtUeberzogen(Kunde k)
    {
        Console.WriteLine(string.Format("Prüfe Dispo für Kunden {0} {1}", k.Name));
        return true;
    }
}

Nun stellen wir uns die Klasse Hypothek zusammen, welche aus den 3 Subklassen Konto, Darlehen und Kreditkarte besteht, auf die wir aber später von außen nicht mehr zugreifen möchten / brauchen.

class Hypothek
{
    private Konto _konto = new Konto();
    private Darlehen _darlehen = new Darlehen();
    private Kreditkarte _kreditkarte = new Kreditkarte();
 
    public bool IstGeeignet(Kunde k, int betrag)
    {
        Console.WriteLine("{0} möchte ein Darlehen über {1:C} haben", k.Name, betrag);
 
        bool geeignet = true;
 
        // Prüfe kreditwürdigkeit des Kunden
        if (!_konto.HatGenugGuthaben(k, betrag))
        {
            geeignet = false;
        }
        else if (_darlehen.HatDarlehen(k))
        {
            geeignet = false;
        }
        else if (!_kreditkarte.HatNichtUeberzogen(k))
        {
            geeignet = false;
        }
 
        return geeignet;
    }
}

Diese Fassade kann nun dazu benutzt werden, um die kreditwürdigkeit des Kunden zu prüfen, ohne dabei selbst auf die Subklassen zugreifen zu müssen. Das bietet den immensen Vorteil, dass die Prüfung nun in den jeweiligen Subklassen erweitert werden kann, ohne dass die Fassade oder die explizite Prüfung des Kunden an mehreren Stellen geändert werden muss. So können wir nun prüfen:

static void Main()
{
    var k = new Kunde { Name = "Max Mustermann" };
    var h = new Hypothek();
 
    bool geeignet = h.IstGeeignet(k, 250000);
    Console.WriteLine(k.Name + " wurde " + (geeignet ? "angenommen" : "abgelehnt"));
}

Und wie immer dürft ihr den Code verwenden und ändern wie ihr lustig seid!

Der Prototype ist ein Entwurfsmuster aus der Kategorie der Erzeugungsmuster (Creational Patterns), ähnlich wie der bereits beschriebene Singleton. Dabei erzeugt der Prototype neue Instanzen eines Objektes bzw. einer Klasse auf Basis einer bereits definierten Vorlage, die für neue Instanzen schlichtweg geklont werden, statt alle Felder und Eigenschaften neu zu setzen.

In den meisten Fällen kommt immer dann ein Prototype zum Einsatz, wenn das Erzeugen neuer Instanzen von Klassen sehr kostspielig ist, die Instanzen sich aber grundsätzlich sehr ähnlich sind. Es gibt hier noch eine Reihe von anderen Gründen die ich gerne zitieren möchte:

“Ein Prototyp findet Anwendung, wenn die Erzeugung weiterer Instanzen einer Klasse teuer ist und sich die Objekte ähneln, die zu instanziierenden Klassen erst zur Laufzeit bekannt sind, eine Hierarchie von Fabriken parallel zu einer Hierarchie von Produkten vermieden werden soll oder wenn die Objekte einer Klasse nur wenige Zustandskombinationen annehmen können; oder wenn die Bearbeitung von Vorlagen sehr ähnlich oder gleich der von Objekten ist.” – Quelle: wikipedia.de

Um den Prototype in Aktion sehen zu können, benötigen wir zuerst ein passendes Beispiel, welches wir uns überlegen müssen. Im Internet bin ich häufig über einen Farbenmanager gestolpert, der entweder nicht korrekt implementiert oder schlecht kommentiert wurde, daher möchte in an einem solchen Beispiel einmal die Funktionsweise des Prototypes erklären.

Als Erstes brauchen wir hier eine Klasse, welche von ICloneable abgeleitet ist, damit wir die Clone() Methoden nutzen können. Die Klasse enthält die Grundbausteine einer jeden Farbe, die RGB Werte, sowie die oben bereits genannte Methode.

class Farbe : ICloneable
{
    // Roten Anteil der Farbe holen oder setzen
    public byte R { get; set; }
 
    // Grünen Anteil der Farbe holen oder setzen
    public byte G { get; set; }
 
    // Blauen Anteil der Farbe holen oder setzen
    public byte B { get; set; }
 
    // Die Clone() Methode
    public object Clone()
    {
        return this.MemberwiseClone();
    }
}

Das ist nun zunächst unsere Basis-Klasse, welche die grundlegenden Farbeigenschaften enthält, die wir für jede neue Farbe brauchen. Als Nächstes definieren wir uns eine ENUM, welche bestimmte Farben bereits enthält. Hier einmal die Basis-Farben rot, grün, blau sowie eigene, selbst zu definierene Farben.

enum FarbTyp
{
    Rot,
    Gruen,
    Blau,
    Eigene1,
    Eigene2,
    Eigene3
}

Um das Ganze nun einfacher und sauberer handhaben zu können, basteln wir uns noch eine FarbManager Klasse, welche mit Hilfe eines Dictionary unsere Farbtypen und unsere Farben beinhaltet.

class FarbManager
{
    private Dictionary<FarbTyp, Farbe> _farben = new Dictionary<FarbTyp, Farbe>();
 
    // Holt oder setzt die Farbe
    public Farbe this[FarbTyp typ]
    {
        get { return _farben[typ]; }
        set { _farben.Add(typ, value); }
    }
}

(Achtung, an dieser Stelle werden < als &lt; und > als &gt; dargestellt!)

Und schon steht unser Grundgerüst für den Prototype! Jetzt können wir in der Main() Methode unseren FarbManager initialisieren und unsere Farbe hinzufügen. Zum Schluss sehen wir, wie wir mit der Clone() Methode einzelne Farben kopieren können.

static void Main()
{
    var farbmanager = new FarbManager();
 
    // Standardfarben
    farbmanager[FarbTyp.Rot] = new Farbe { R = 255, G = 0, B = 0 };
    farbmanager[FarbTyp.Gruen] = new Farbe { R = 0, G = 255, B = 0 };
    farbmanager[FarbTyp.Blau] = new Farbe { R = 0, G = 0, B = 255 };
 
    // Eigene Farben
    farbmanager[FarbTyp.Eigene1] = new Farbe { R = 54, G = 90, B = 20 };
    farbmanager[FarbTyp.Eigene2] = new Farbe { R = 128, G = 128, B = 128 };
    farbmanager[FarbTyp.Eigene3] = new Farbe { R = 80, G = 120, B = 230 };
 
    // Farben aus dem FarbManager benutzen
    var farbe1 = farbmanager[FarbTyp.Rot].Clone() as Farbe;
    var farbe2 = farbmanager[FarbTyp.Eigene2].Clone() as Farbe;
}

Hier haben wir nun in den Objekten farbe1 und farbe2 die Eigenschaften R, G und B. In diesen sind die vorher durch den FarbManager festgelegten Bytes gespeichert, die unsere eigentlichen Farben darstellen. Möchte ich nun im späteren Verlauf meiner Anwendung eine Farbe benutzen, so muss ich diese nicht immer komplett neu implementieren, sondern kann über die Clone() Methode des FarbManagers mir meine Objekte jederzeit definieren. Zusätzlich hat diese Vorgehensweise den Vorteil, dass ich Farben und deren Eigenschaften, zentral an einer Stelle definieren kann ohne jederzeit im gesamten Quellcode nach neuen Farben suchen zu müssen.

Wie immer an dieser Stelle wünsche ich viel Spaß beim Testen und Tüfteln!

Quellen: Inspiration des Prototypes, dofactory

Da die Hackergruppe LulzSec in den letzten 50 Tagen sehr aktiv war und sich somit in den Besitz von hunderttausenden Accounts bringen konnte stellt sich dem Ein oder Anderen die Frage: “Ist mein Account denn nun auch betroffen?”. Auch wenn man Passwörter immer in einem festdefinierten Zeitfenster ändern sollte, so möchte der vorsichtige User ja nicht gleich alle seine Accounts umstellen. Genau für diese Benutzer gibt es nun gleich zwei Tools mit denen sich feststellen lässt, ob sich ihr Account unter den Opfern der LulzSec Bewegung befindet.

Nachdem die LulzSec Mitglieder nun zu Anonymous abgewandert sind, besteht wohl erstmal keine größere Gefahr mehr für den normalen Nutzer. Anonymous hat sich nämlich im Gegensatz zur LulzSec Gruppe eher dem Hacken von Regierungsmaterial verschrieben ist somit Vorreiter der #AntiSec Bewegung. Dennoch kann man rückwirkend sagen, dass die Jungs von LulzSec doch sehr motiviert bei der Sache waren. Hier ein kleiner Überblick über die neusten Hacks:

• 50 Days of Lulz.txt 2.64 KiB
• AOL internal data.txt 63.6 KiB
• AT&T internal data.rar 314.59 MiB
• Battlefield Heroes Beta (550k users).csv 24.67 MiB
• FBI being silly.txt 3.82 KiB
• Hackforums.net (200k users).sql 111.2 MiB
• Nato-bookshop.org (12k users).csv 941.8 KiB
• Office networks of corporations.txt 3.87 KiB
• Private Investigator Emails.txt 2.52 KiB
• Random gaming forums (50k users).txt 6.08 MiB
• Silly routers.txt 67.7 KiB
• navy.mil owned.png 240.51 KiB

Um nun sicherzugehen, dass man selbst nicht in diesen Dokumenten auftaucht, bietet die Seite “Should I Change My Password” einen Check an, der die meisten Dokumente nach E-Mail Adressen oder Nicknames überprüft und euch Bescheid gibt, sofern diese Daten in den Dokumenten bzw. Datenbanken gefunden wurde.

Im gleichen Atemzug hat Gizmodo ebenfalls eine Prüfung online gestellt. Hier werden nochmals andere Dokumente nach E-Mails und Co. durchforstet. Sollten eure E-Mail Adressen bei einem dieser Checks gefunden werden, ist dringend zur Änderung eurer Passwörter zu raten! Ich jedenfalls schien diesmal verschont geblieben zu sein…

Quellen: Liste der Dokumente, Gizmodo

Nachdem ich hier bereits den Singleton beschrieben habe, folgt nun ein weiterer Design Pattern (Entwurfsmuster), diesmal allerdings aus dem Bereich der Behavioral Patterns (Verhaltensmustern). Der sogenannte Memento, oder auch als Token bezeichnet, soll den internen Zustand eines Objektes erfassen und diesen nach außen verlagern können, ohne dabei die Kapselung dieses Objektes zu beschädigen.

Der Memento sollte immer dann zum Einsatz kommen, wenn ein aktueller Zustand eines Objektes zwischengespeichert werden soll oder aber eine direkte Schnittstelle zur Ermittlung dieses Zustandes Details zur Implementierung aufzeigen würde. Letzteres kann ebenfalls mit dem Memento Pattern verhindert werden.

Prinzipiell ist der Memento nur eine Vereinigung von Serialize und Deserialize Methoden in C# mit der Möglichkeit das Objekt so zwischen zu speichern. Wir benötigen hierzu also zunächst einmal eine Klasse die wir serialisieren können.

[Serializable]
class KundenKonto
{
  private string _vorname;
  private string _nachname;
  private string _kontonummer;
  private double _guthaben;
 
  public string Vorname { get { return _vorname; } set { _vorname = value; } }
  public string Nachname { get { return _nachname; } set { _nachname = value; } }
  public string Kontonummer { get { return _kontonummer; } set { _kontonummer = value; } }
  public double Guthaben { get { return _guthaben; } set { _guthaben = value; } }
 
  // Dient zum Setzen (Serialisieren) des Memento
  public Memento SaveMemento()
  {
    var memento = new Memento();
    return memento.Serialize(this);
  }
 
  // Dient zum Zurücksetzen (Deserialisieren) des Memento
  public void RestoreMemento(Memento memento)
  {
    KundenKonto konto = (KundenKonto)memento.Deserialize();
    this.Vorname = konto.Vorname;
    this.Nachname = konto.Nachname;
    this.Kontonummer = konto.Kontonummer;
    this.Guthaben = konto.Guthaben;
  }
}

Wie man nun sieht, haben wir eine Klasse, die Informationen zum Konto sowie zwei Methoden zum Speichern und Zurücksetzen des Objektes enthält. Diese zwei Methoden erfordern allerdings ein Objekt vom Typ Memento, welches wir in folgender Klasse definieren.

class Memento
{
    private MemoryStream _stream = new MemoryStream();
    private SoapFormatter _formatter = new SoapFormatter();
 
    // Serialisieren
    public Memento Serialize(object mem)
    {
        _formatter.Serialize(_stream, mem);
        return this;
    }
 
    // Deserialisieren
    public object Deserialize()
    {
        _stream.Seek(0, SeekOrigin.Begin);
        object mem = _formatter.Deserialize(_stream);
        _stream.Close();
 
        return mem;
    }
}

Diese Klasse erlaubt es uns nun, sämtliche serialisierbaren Objekte in ihrem aktuellen Zustand zu speichern. Erforderlich ist lediglich die korrekte Implementierung der SaveMemento() und RestoreMemento() Methoden in den jeweiligen Klassen und diese mit [Serializable] zu kennzeichnen. Zusätzlich brauchen wir noch eine sogenannte Caretaker Klasse, in die wir den Memento zwischenspeichern können. Aufgebaut ist sie wie folgt:

class KundenKontoMemory
{
  public Memento Memento { get; set; }
}

Im Ergebnis können wir nun in unserer Main() Methode das Objekt initialisieren und mit den Methoden SaveMemento() im KundenKontoMemory speichern bzw. mit RestoreMemento() aus dem KundenKontoMemory zurückholen.

static void Main()
{
  // Initialisierung
  var meinKonto = new KundenKonto
  {
    Vorname = "Max",
    Nachname = "Mustermann",
    Kontonummer = "123456789",
    Guthaben = 25000.0
  };
 
  // Memento erstellen und sichern
  var backupKonto = new KundenKontoMemory();
  backupKonto.Memento = meinKonto.SaveMemento();
 
  // Daten manipulieren
  meinKonto.Vorname = "Testi";
  meinKonto.Nachname = "Testmann";
  meinKonto.Kontonummer = "987654321";
  meinKonto.Guthaben = 1000;
 
  // Memento rücksichern
  meinKonto.RestoreMemento(backupKonto.Memento);
}

So haben wir unser Objekt nun veräußern, also zwischenspeichern können, ohne die Kapselung des Objektes an sich zu beschädigen. Objekte können so auch ohne Weiteres zwischen Applikationen ausgetauscht werden, da die serialisierten Objekte zusätzlich noch komprimiert werden können.

Der oben beschriebene Code steht jedem zur freien Verwendung zur Verfügung, ich wünsche viel Spaß!

Oftmals ist es nicht schwer, ein kleines Stück Software oder ein gutes Tool zu entwickeln. Doch was tun, wenn man ein wesentlich größeres und aufwendigeres Projekt realisieren möchte. Ich stand auch schon häufig vor diesem “Problem”, da ich häufig keinen passenden Anfang finde. Wenn das Grundkonzept steht möchte man viel zu oft schnell ans Programmieren. Generell auch eine feine Sache, die von Enthuisasmus zeugt. Aber Vorsicht! Klassen einfach drauf los zu programmieren ist eine Todsünde!

Es ist zwangsläufig notwendig, sich vorher mit seinen Klassen auseinander zu setzen, um nicht später alles über den Haufen werfen zu müssen, wenn man merkt, dass man etwas wichtiges vergessen hat. In diesem Prozess sind sogenannte Design Patterns von absoluter Notwendigkeit! Diese Entwicklungs Muster dienen dazu, grundsätzliche Strukturen und Verfahren in Euer Programm zu bringen. Ich möchte mich im ersten Teil dieser Serie mit dem Singleton, also der Einmal-Instanzierung einer Klasse, beschäftigen.

Fängt man ein neues Projekt an, so hat man meistens einen Basis-Layer, der die Verbindungungen mit Datenbanken reglementiert (Database Access Layer [DAL]) oder Konfigurationen aus einer XML oder anderen Formaten ausliest. Gerade beim DAL ist es von bedeutender Relevanz, dass pro Anwendung nur eine einzige DAL-Initiierung erfolgen darf! Man möchte schließlich nicht 3 oder 4 Mal die gleiche Datenbank mit unterschiedlichen Objekten, mit vielleicht sogar unterschiedlichen Parametern ansprechen.

Der Design Pattern “Singleton” reglementiert die Instanzierung von Klassen. Dabei ist die theoretische Vorgehensweise sehr einfach. Wichtig ist zuersteinmal, dass wir den Konstruktor von außen nicht mehr zugänglich machen. Dieser ist nun private und kann nur vom Singleton aufgerufen werden. Soweit, so gut. Nun müssen wir uns überlegen, wie wir prüfen können, ob es bereits eine Instanz unserer Klasse gibt. Das machen wir indem wir in der Klasse eine Variable vom Typ der zu überwachenden Klasse anlegen und auf NULL setzen.

Der Singleton

private static volatile Klassenname _instance = null;
private static object m_lock = new object();
 
public static Klassenname GetInstance()
{
  if (_instance == null)
  {
    lock(m_lock)
    {
      if (_instance == null)
      {
        _instance = new Klassenname();
      }
    }
  }
 
  return _instance;
}

Diese Methodik bezeichnet auch schon den Singleton. Wir prüfen, ob eine Instanz der Klasse angelegt wurde. Ist dies nicht der Fall, sperren wir den folgenden Code für weitere Threads, die eventuell auf diese Klasse zugreifen könnten und prüfen erneut, ob eine Instanz vorliegt (DoubleLock). Ist dies nun immernoch nicht der Fall, so erzeugen wir eine neue Instanz, rufen also den Konstruktor auf.

Nun wurde die Variable _instance auf die gerade erzeugte Instanz festgelegt und kann bei jedem weiteren Aufruf von GetInstance() an das Objekt vom Typen Klassenname zurückgegeben werden. Doch wofür das alles? Ganz einfach: Wir brauchen keine Objekte mehr zwischen mehreren Klassen hin und her zu übergeben. Diese Klassen können nun mit GetInstance() einfach der vollständig initialisierte Klasse holen und mit all ihren Werten und Parametern arbeiten.

GetInstance() im Einsatz

// Aufruf der Klassen-Instanz
Klassenname myClass = Klassenname.GetInstance();
 
// Aufruf mit Hilfe eines Interfaces
IKlassenname myClass = Klassenname.GetInstance();

Diese Vorgehensweise lässt sich auch ideal erweitern, falls Ihr nur eine gewisse Anzahl an Instanzen zulassen wollte. Sowas kann gebraucht werden, wenn man Zugriff auf mehr als eine Datenbank haben möchte. In diesem Fall kann man dem Singleton noch Parameter übergeben, welche er dazu nutzen kann, ebenfalls den Konstruktor parameterisiert aufzurufen. Probiert es aus, Euch sind so gut wie keine Grenzen gesetzt!

So, nach langer langer Pause habe ich mir nun ein Herz gefasst und werde diesen Blog wiederbeleben. Mit dem Inhalt geht es wie gewohnt weiter, das heißt Rezensionen von Hard- und Software, Tipps & Tricks im Bereich der Software-Entwicklung und alles rund um das Thema Sicherheit im Netz.

Da mittlerweile doch schon einiges an Zeit in diesen Blog geflossen ist, wäre es sehr schade, wenn er einfach in der Flut des Netzes unterginge. Ich hoffe diesmal eine gewisse Kontinuität der Beitrage zu gewährleisten, damit es dem geneigten Leser auch nicht langweilig wird. An dieser Stelle bleibt mir dann wohl nur noch viel Spaß beim Lesen zu wünschen!

Es ist nicht wirklich eine Revolution und auch nichts grundlegend Neues. Dennoch benutze ich seit heute ein nettes kleines App namens Pingchat!. Dieses kann, wie bereits einige andere Apps auch, kostenlos “SMS” Nachrichten zwischen Usern versenden. Dazu muss der andere User natürlich auch das kostenlose App besitzen.

Im Prinzip ist es genial einfach: Man lädt sich das App aus dem Store auf sein iPhone herunter. Nach der Installation wird man beim ersten Start dazu aufgefordert sich einen Account anzulegen. Wenn das getan ist, kann es auch schon losgehen, man muss lediglich seine Freunde adden.

Die vier primären Tab-Reiter am unteren Rand der App erlauben einem die Homepage des Herstellers zu besuchen, um die neusten Informationen über das App zu beziehen, seine Kontakt-Liste zu durchsuchen, Einstellungen zu ändern oder andere auf Pingchat! aufmerksam zu machen.

Weiterhin kann man die Kontakte von Pingchat! mit seinem normalen Adressbuch verknüpfen und diese an andere Nutzer versenden.

Zudem gibt es die Möglichkeit Nachrichten an mehrere Benutzer gleichzeitig zu versenden, um so eine Art Gruppenraum zu eröffnen. Dort, sowie in den normalen Unterhaltungen, können Bilder, Videos und Tonaufnahmen versendet werden. Diese lassen sich mit einem Fingerdruck auf das gewünschte Element sofort auf Eurem iPhone speichern.

An Hand der grünen Häkchen, kann der Versender sehen, ob der Empfänger die Nachricht bereits gelesen hat oder noch nicht. Mit eingeschalteter Push-Funktion erhält man die Nachrichten, wie bei SMS üblich, direkt auf dem Home-Screen angezeigt.

Mein Fazit ist also, dass das App alles in allem eine gute kostenfreie Alternative zu anderen Programmen rund um dieses Thema ist. Da es bald ebenso eine kostenfreie Version für Android-Nutzer geben soll, wäre Pingchat! also bald eine der wenigen Cross-Platform-Clients, die die SMS bald überflüssig machen sollte.

[Bilder von der offiziellen iTunes App Store Seite von Pingchat!]

Wie ich schon damals sagte, möchte ich den Blog auch gerne für eigene Themen nutzen. Darunter fallen natürlich auch Gebiete, die mir während meiner Arbeitszeit begegnen und die ich recht interessant finde. An dieser Stelle möchte ich mich mit einem exponentiellen Glättungsverfahren auseinandersetzen, welches in der Lagerverwaltung eine größere Rolle spielt.

Definition

Doch was sind eigentlich Glättungsverfahren? In der Mathematik beziehungsweise Statistik werden solche Verfahren genutzt, um Trendkomponenten, welche sich durch keine funktionale lineare oder nichtlineare Beziehung darstellen lassen, durch eine sogenannte glatte Komponente mit Hilfe gleitender Durchschnitte zu bestimmen.

Beschreibung

Klingt nun alles sehr theoretisch und unverständlich? Ist es aber letztenendes garnicht. Im Prinzip habt Ihr eine Kurve mit einem festem Beobachtungszeitraum. Zu jedem dieser Zeitpunkte liegt ein beliebiger Wert vor (y1, y2, y3 … yn). Jetzt errechnen wir einfach geglättete Schätzwerte, die sich auf Ergebnisse der vorherigen Zeitpunkte beziehen. Neben unseren Zeitreihenwerten y(t) brauchen wir noch einen Glättungsfaktor alpha, der größer null aber kleiner eins sein muss (0 <= a <= 1). Daraus ergibt sich die Formel, y’(t) ergibt dabei den geglätteten Wert:

y’(t) = a * y(t) + (1-a) * y’(t-1)

Der Schätzwert y’(t) liefert hier den Prognosewert für den Zeitpunkt t+1. Liegt im Zeitpunkt t+1 eine weitere Beobachtung vor, so kann dir Prognose für t+2 ermittel werden, usw.

Beispiel

Es seien insgesamt zehn Zeitreihenwerte (y0 bis y10) gegeben. Diese sollen nun mit einem Glättungskoeffizienten von alpha (a) = 0,3 geglättet werden. Der Anfangswert y’0 soll 19 betragen.

y’1 = 0,3 * 20 + 0,7 * 19 = 6 + 13,3 = 19,3
y’2 = 0,3 * 18 + 0,7 * 19,3 = 5,4 + 13,51 = 18,91
y’3 = 0,3 * 21 + 0,7 * 18,91 = 6,3 + 13,24 = 19,54
…

Dadurch ergibt sich folgende Tabelle und Grafik:

Die Grafik zeigt die Glättung für α = 0,6 sowie α = 0,3 und α = 0,1. Man sieht, dass der kleinere Glättungsfaktor die Zeitreihe stärker glättet, denn hier geht der aktuelle Wert nur mit einem Gewicht von 0,3 ein, wogegen die „mittleren“ Vergangenheitswerte mit 0,7 berücksichtigt werden.

Programmcode

// yt = (19, 20 , 18 , 21 , 22 , 19 , 21 , 18 , 20 , 21 , 17 )
// result = (19, 19.3, 18.91, 19.54, 20.28, 19.89, 20.23, 19.56, 19.69, 20.08, 19.16)
// Exponentielle Glättung: yt = Zeitwerte, a = alpha, result = geglättete Werte
privatestaticdouble[] expsmoothing(double[] yt, double a) {
double[] result = newdouble[yt.length];

result[0] = yt[0];
for (int i = 0; i < yt.length – 1; i++) {
if (i == 0) { result[i+1] = a * yt[i+1] + (1-a) * yt[i]; }
else { result[i+1] = a * yt[i+1] + (1-a) * result[i]; }
}
return result;
}

Fazit

Diese Methode ist sehr nützlich, um Kurvenverläufe zu beeinflussen und kann ohne größere Umstände implementiert werden. Da ich mich gerade mit Java beschäftige, ist der Code in dieser Programmiersprache geschrieben. Dieser funktioniert allerdings auch ohne viel Modifikation in anderen Sprachen, also viel Spaß!

Vielleicht lässt es sich schon am Titel erahnen, aber ich finde leider momentan keine Zeit, um dieses schöne Blog-System zu pflegen. Leider hat sich bis dato auch noch kein Freiwilliger finden lassen, der uns tatkräftig unterstützen würde. Ich hoffe zwar, dass ich in den nächsten Wochen wieder regelmäßig Zeit finde dieses Blog mit Leben zu füllen, aber versprechen kann ich nichts.

Dies liegt zum Einen an meiner Arbeit, die mich momentan, und auch zum Glück, voll und ganz fordert. Es gibt stetig neue Ideen und Projekte, die verwirklicht werden wollen und diese nehmen natürlich auch einiges an Freizeit in Anspruch: Schließlich ist es nicht mein Job, sondern meine Berufung!

Zudem laufen nebenbei auch andere private Projekte, die gefördert und aufgebaut werden möchten. Und wenn es meine Freizeit doch mal zulässt, arbeite ich an Konzepten für das Dortmund Project, welches auch dieses Jahr wieder gute Projekte im Bereich der Informations-Technologie sucht.

Ich hoffe auf ein bisschen Verständnis und gelobe Besserung in naher Zukunft. Doch da ich mich gerade in der Blüte meiner Kreativität und Lernbegierde befinde kann ich momentan noch nichts versprechen. Ich hoffe aber weiterhin darauf, dass mir ein paar findige Blog-Fetischisten unter die Arme greifen.