Warum? Das dürfte sie Frage sein die sich als erstes stellt. Warum sollte man Code schreiben der nicht compiliert? Wer C/C++ kennt, kennt höchst wahrscheinlich auch assert. Das Makro assert(exp) überprüft ob der Ausdruck exp wahr oder falsch ist, wenn der Ausdruck falsch ist werden die mit atexit angegebenen Funktionen aufgerufen und das Programm danach beendet. Das ist nützlich um das Programm kontrolliert zu beenden wenn es sich in eine ausweglose Situation manövriert hat. Mit assert wird eine Bedingung zur Laufzeit überprüft, es gibt aber auch Bedingungen die bereits zu Compilezeit feststehen. In solch einem Fall ist es sinnvoll den Code nur bei erfüllter Bedingung zu compilieren, da das Programm ohnehin nicht (sinnvoll) lauffähig wäre. Man könnte auch sagen es geht darum die Menge an Code zu verringern, die syntaktisch korrekt aber semantisch falsch ist.

Für alle denen das jetzt noch zu theoretisch ist kommt hier ein Beispiel:

template<typename T,unsigned int width, unsigned int height>
class Matrix{
  public:
  void setToIdentity(){
    for(unsigned int i; i<width; i++){
      values[i*width+i]=1;
    }
  }

 private:
 T values[widht*height];
};

Die Breite und Höhe einer Matrix stehen schon beim compilieren fest. Eine Einheitsmatrix (oder Identität) ist immer quadratisch, die Funktion setToIdentity() soll also nur Funktionieren wenn die Höhe gleich der Breite ist. Wird bei einer Matrix mit ungleichen Werten versucht setToIdentity() aufgerufen, soll das Programm nicht compiliern (weil die Einheitsmatrix dann nicht definiert ist). Wir brauchen also ein Konstrukt das bei true als Wert compiliert und bei false einen Fehler verursacht.

Eine Lösung aus dem Buch Modern C++ Design:

template<bool>
struct StaticChecker{
  StaticChecker(...){};
};
template<>
struct StaticChecker<false>{};
#define STATIC_CHECK(expr,msg)\
{\
class ERROR_##msg {};\
(void)sizeof(StaticChecker<(expr) != 0>((ERROR_##msg())));\
}

Diese Makro erzeugt eine lokale Klasse und übergibt diese als Parameter an den Konstruktor von StaticChecker. StaticChecker<true> hat als Parameter im Konstruktor eine Ellipse, d.h. als Parameter wird hier einfach alles akzeptiert. Ist exp aber falsch wird ein Objekt der Klasse StaticChecker<false> erzeugt und dieser template Spezialisierung fehlt der Konstruktor mit Ellipse. Der Compiler wird hier sagen das StaticChcker<false> keinen Konstruktor mit dem Parameter ERROR_msg hat. Über die Klasse ERROR_msg kann man also noch einen Hinweis geben was falsch gelaufen ist. Im Beispiel sähe das dann so aus:

void setToIdentity(){
  STATIC_CHECK(width==height,WIDTH_AND_HEIGHT_NOT_EQUAL)
  for(unsigned int i; i<width; i++){
    values[i*width+i]=1;
  }
}

Schön an dieser Lösung ist das man einen Hinweis auf den Fehler geben kann und das einen die IDE wahrscheinlich in die richtige Zeile bringt. Unschön ist aber der Rückgriff auf Makros. Meiner Meinung nach sollte man Makros nur als das verwenden was sind: als Mechanismus zur Textersetzung. Komplexere „Programmierung“ sollte man nicht mit Makros machen. Makros haben z.B. Probleme wenn in dem Ausdruck ein Komma vorkommt, was die Verwendung von templates in STATIC_CHECK erschwert. Daher hier eine Alternative die auf Makros verzichtet:

template<bool>
struct COMPILE_TIME;

template<>
struct COMPILE_TIME<true>{
 static void CHECK_FAILED(){};
};

template<>
struct COMPILE_TIME<false>{
};

template<bool exp>
struct CompileTimeCheck{
 static void check(){COMPILE_TIME<exp>::CHECK_FAILED();};
};

Diese Lösung hat den Vorteil das sie typsicher ist und auch mit komplizierten Ausdrücken funktioniert, ein Nachteil ist das es keinen Hinweis auf die Ursache des Fehlers gibt. Hier nochmal das Beispiel mit der alternativen Lösung:

void setToIdentity(){
  CompileTimeCheck<width == height>::check();
  for(unsigned int i; i<width; i++){
    values[i*width+i]=1;
   }
}

So, ich hoffe ich konnte klar machen warum es manchmal sinnvoll sein kann dafür zu sorgen das Code nicht kompiliert.

„Eines ist also klar: Niemand der im weltweiten Netz unterwegs ist, ist vor der Online-Kriminalität sicher.“

aufregen, oder das Hacker als Synonym für Kriminelle im Internet verwendet wird, aber an den Blödsinn hat man sich ja schon gewöhnt. Nein, was mich hier fassungslos macht ist Herr Jansen, Vorsitzender des BDK. Der entblödet sich doch tatsächlich folgenden Satz zusagen:

„Wenn wir nicht auf die Rechner der Täter gucken, in dem Augenblick, oder auf die Rechner der Opfer gucken, in dem Augenblick wo Straftaten passieren, wir schon wenige Minuten später möglicherweise, oder Stunden später, wenn  wir dann alarmiert werden:“Mir ist was passiert.“ überhaupt keine Ansatzpunkte, überhaupt keine Spuren mehr sicher stellen können, wenn wir das nicht sofort per Knopfdruck veranlassen.“

Äh, Moment mal? Wie war das? Rechner der Opfer? Wir brechen bei ihnen ein und schünffeln mal ein bisschen rum, falls ein Einbrecher auftaucht? Und wie passt man „den Augenblick wo Starftaten passieren“ ab? Precrime? Und was ist mit „per Knopfdruck veranlassen“? Richtervorbehalt, anyone?

Wurde uns nicht erzählt die sogenannte Onlinedurchsuchung wäre nur für Terroristen und auch höchstens zehnmal pro Jahr? Und jetzt sollen auch mal die Rechner der Opfer trojanisiert werden? So schnell kann  man von der Maßnahme gegen Terroristen zur Totalüberwachung der Bevölkerung (Opfer) kommen. Das ganze natürlich bequem „auf  Knopfdruck“.

Die Leute die sowas fordern sollten mal das Grundgesetz lesen und vorsichtshalber vom Verfassungsschutz beobachtet werden. Und Spon hat mal wieder ein prima Propaganda Video abgeliefert, in dem solcher Quatsch nicht nur unwidersprochen vorkommt, sondern danach auch noch indirekt bestätigt wird.

Naja, hier war also eher nicht viel zu holen. Ich wollte dann noch wissen wie HanseNet zwischen Kunden mit aktivierter Umleitung und deaktivierter Umleitung trennt. Die ersten Antworten darauf hab ich nicht verstanden aber es wurde mehrmals gesagt das man ja meine Bestandsdaten sowieso hätte und ich müsste mich ja mit Passwort einwählen und da würde das dann auch gespeichert. Meine Frage ob Kunden mit deaktivierter Umleitung bei der Einwahl einen anderen DNS Server zugewiesen bekommen (wäre für mich die einfachste und sauberste Trennung) wurde verneint.
Nach dem ich dann noch ein paar mal nachgefragt habe wie das ganze läuft, reime ich mir das so zusammen, dass sie auf dem DNS Server tatsächlich gucken welche ip gerade nach einem „host unkown“ gefragt hat und wenn die ip gerade jemandem mit Umleitung gehört wird aus dem „host unkown“ auf magische Art eine ip. Auf meine Bemerkung das Alice dann ja in meinem Datenstrom rummanipuliert, wurde mir gesagt dass ich das dann aber sehr kleinlich auslegen würde (Ja tue ich!) und da säße ja niemand der sich meine Pakete angucken würde das passiere ja automatisch und dass man ja sowas eh täte man müsse ja z.B. auch routen (??).

Es ging dann noch ein bisschen hin und her (Ich als Kunde finde das doof – Ja ABER, es gibt auch Kunden die finden das gut…, Die rufen sonst bei uns an und sagen ihr Internet wäre kaputt…), letztendlich war klar dass es da kein Zusammenkommen gibt. Ich hab dann noch gefragt ob sie mir auch noch schriftlich antworten, aber da wurde mir dann gesagt das ja mit dem Anruf alles geklärt wurde und mir wurde nochmal das OptOut angeboten (ich hatte in dem Brief darum gebeten die Antwort veröffentlichen zu dürfen).

Fazit: Mit der Aktion hat Alice/HanseNet bei mir jedenfalls keine Sympathiepunkte gewonnen. Und das sie tatsächlich auf einzelne DNS Anfragen gucken finde ich ziemlich erschreckend. Muss ich jetzt auch noch meinem Provider misstrauen?

Update:
Wenn ihr selber bei Alice seid kann euch nur empfehlen auch mal einen Papier-Brief zu schicken, in dem ihr klar macht dass ihr sowas ablehnt. Das wird durchaus wahgenommen und 55 cent sind nicht zuviel für die Netzneutralität.

Der Spiegel ist einfach nicht mehr ernstzunehmen und wird immer mehr zum Propaganda-Organ der Regierung. Was auch dieser selten dämliche Artikel zeigt. Leider hat sich das noch nicht so rumgesprochen und so gilt der Spiegel bei vielen noch als seriös und „Strumgeschütz der Demokratie“.

Das sieht dann vieleicht so aus:

  class Vector3{
  public:
    Vector3(){}
    float& operator[](unsigned int index){
      return vec[index];
    }
    const float& operator[](unsigned int index) const{
      return vec[index];
    }
    const Vector3 operator+(const Vector3& v) const{
      Vector3 out;
      out[0]=vec[0]+v[0];
      out[1]=vec[1]+v[1];
      out[2]=vec[2]+v[2];
      return out;
    }
  //more operators and methods
  private:
  float vec[3];
  };

Ok, jetzt haben wir eine nette Klasse mit schnellem Code. Aber was wenn wir mit vierdimensionalen Vektoren rechnen wollen? Oder mit 5,6,7 oder 23dimensionalen? Oder wenn es mal ganz genau sein muss und wir mit double rechnen wollen? Es ist klar das diese Art zu programmieren nicht skaliert. Aber wozu gibt es den new operator?
Also nächster Versuch:

class DynVector{
  public:
    DynVector(unsigned int s):size(s){
      vec = new float[s];
    }
    ~DynVector(){
      delete[] vec;
    }
    float& operator[](unsigned int index){
      return vec[index];
    }
    const float& operator[](unsigned int index) const{
      return vec[index];
    }
    const DynVector operator+(const DynVector& v) const{
      DynVector out(size);
      for(unsigned int i=0;i<size;i++){
        out[i]=vec[i]+v[i];
      }
      return out;
    }
  private:
  unsigned int size;
  float* vec;
  };

So, jetzt haben wir Vektoren beliebiger Größe. Aber damit haben wir uns neue Probleme eingehandelt. Wir müssen jetzt dynamisch Speicher allokieren, was langsamer als auf dem Stack ist. Außerdem haben wir eine Schleife im Operator was auch noch etwas langsamer ist und das Problem der verschiedenen Typen ist auch noch da. Aber das Hauptproblem ist, dass der Compiler nicht feststellen kann ob wir versuchen Vektoren unterschiedlicher Größe zu addieren. Natürlich können wir die Größe überprüfen, aber was tun wenn es mal nicht passt? Weiter rechnen ist nicht möglich, also wird es wohl auf ein kontrolliertes Beenden des Programms hinauslaufen. Keine besonders gute Lösung.

Templates for the rescue!

template<typename T,unsigned int size>
class Vector{
  public:
  Vector(){}
  T& operator[](const unsigned int index){
    return vector[index];
  }
  T const& operator[](const unsigned int index) const{
    return vector[index];
  }
  const Vector operator+(const Vector& v) const{
    Vector out;
    for(unsigned int i=0; i<size; i++){
      out[i]=v[i]+vector[i];
    }
    return out;
  }
  private:
  T vector[size];
};

Jetzt haben wir alles was wir wollen. Wir haben beliebig große Vektoren für alle Typen, die die benötigten Operatoren implementieren, der Compiler verhindert das wir Vektoren addieren die unterschiedliche Größen haben und wir haben schnellen Code. Da die Größe eine Konstante ist kann der Compiler die Schleifen wegoptimieren. Wenn wir wollen könnten wir durch Spezialisierung noch mehr rausholen und z.B. Vector<float,4> mit sse implementieren.

Und natürlich enthält der Link wie er in der mail steht meine mail Adresse. Wer selber mal gucken will: http://newsletter.alice-dsl.de/re?l=9x8zysI2rrd4gqI0&req=ref%3NoOne@No.where

Die zweite Sache ist das Verbiegen von DNS. Die url  www.noone.nowhere lösen die Alice DNS Server zu 64.236.172.120 auf. Äh, hallo? Noch lustiger ist dass es nur mit vorangestelltem www funktioniert. Äh, HALLO? Das ganze endet im Browser dann hier. Auf der Seite gibt es dann einen Link zu einem optOut wo man das Ganze nach Eingabe der Kundendaten abschalten kann. Ende gut alles gut?

Naja, das heist doch das die Alice DNS Server wissen müssen welcher Nutzer welche DNS Anfragen stellt damit sie korrekt antworten bzw. das DNS verbiegen können. Ein Goldschatz an personalisierten Daten. Nachdem jetzt auch noch das ORSN am Jahresende dicht macht, bin ich auf der Suche nach vertrauenswürdigen DNS Servern.

Jetzt war es ja schon so, dass das vom Bundesverfassungsgericht bei neuen Gesetzen in letzter Zeit öffter mal „im Einzelfall andere Balancen festgelegt wurden“. Aber hey, das „zeugt von dem Funktionieren unseres demokratischen Systems“.