Wer diesen Post seltsam findet, der gehört nicht zu den seltenen, die mal zu wenig strampelten oder ist schlichtweg von wenigen Dingen begeistert.

Leben ist egoistische Konkurrenz um Ressourcen, Kooperation ist unwahrscheinlich, aber hilfreich.

Das Leben hat keinen Plan und passiert einfach – Leben ist opportunistisch.

Leben ist eine Minimallösung.

Menschen werden eher nach ihrem Skelett, neuerdings auch nach ihren Gesichtern, als nach ihrem Gehirn bewertet.

Strategien:

Archaisches Verhalten zu heucheln, um nicht nachgeben zu müssen, kann hilfreich sein.

Das Leben ist nicht aufgeschlossen gegenüber nicht bewährten Abhängigkeiten. Intelligenz kann dazu dienen, stabile Abhängigkeiten zu lokalisieren und auf penetrante und doch subtile Art und Weise diese versuchen zu etablieren.

Es gilt, harte Kanäle zu etablieren, die mehr “weiche” Generösität der Individuen untereinander ermöglichen und dennoch nicht den Naturgesetzen widersprechen.

Fazit:

Das Leben sollte diese Fakten verinnerlicht haben, um die Autopoiesis zu garantieren. Diese Fakten können aber auch explizit gelernt und – wie hier – formuliert werden. Eine bereits bewährte Expression dieser Fakten sollte angestrebt werden, um sie aus dem Bewusstsein auszublenden.

Die Antwort wird leichtfallen, sobald wir das Sonderproblem gefunden haben, das die Ausdifferenzierung dieses besonderen Kommunikationsmediums auslöst. Es handelt sich um das Gewinnen neuen, unvertrauten, überraschenden Wissens, also um die Überwindung einer Schwelle der Unwahrscheinlichkeit. Die Erfahrung von “Neuheit” setzt einen Beobachter voraus, der eine Abweichung von Erwartungen feststellen kann. Solange aber der Beobachter seine Erwartung nicht spezifisch kognitiv auffasst, sondern die Frage dieser Modalisierung im Unbestimmten lässt oder gar normativ erwartet, wird die Abweichung ihn stören, und er wird einen Weg zurück in normale Verhältnisse suchen. Kommt es zu einer kognitiven Spezifikation des Erwartens oder gar zu neugierigem Erwarten, wird das Neue in spezifischer Weise interessant; und das gilt nochmals verstärkt, wenn die Neuheit nicht einfach als sachliche Abweichung erfahren, sondern temporal als Differenz zu früheren Zuständen oder Erfahrungen thematisiert wird. Dann ist die Neuheit des Befundes ein Anlaß zur Suche nach nach einer Erklärung, dann stimuliert der Neuheitseindruck die Suche nach neuem Wissen; und Neues wird geradezu gesucht, um ein Anlaß zu sein, Neues zu suchen.

Im Normalfall ist eine Irritation der Punkt, wo man am Ende einer Fahnenstange sitzt – wenn man denn soweit kommt -, um dann zu sagen: “Dünne Luft hier, ich rutsche besser runter.”

Weiter schreibt Luhmann:

Mehr und mehr liegt das Problem nun nicht nur im Bekannten und Unbekannten, woran jedermann interessiert sein müßte, und auch nicht mehr im Wiedererkennen (a-létheia!) des an sich bekannten WIssens, sondern in der Änderung vorhandener Wissensstrukturen. [...] Eben deshalb bildet sich, wenn (aus welchen Zufällen immer) so etwas vorkommt, ein besonderes Medium für Wahrheitskommunikation, das die schockierende Kommunikation gleichwohl trägt oder sie jedenfalls nicht vorab entmutigt und erstickt.

Also geht es auch darum, vorhandene Fahnenstangenfundamente zu versetzen oder zu erneuern. Nur Wiedererkennen langweilt ja auf Dauer. Es geht um das Erkennen und Differenzieren von Sichtweisen. Die neue Art, das Beobachten zu beobachten, das ist auch “neu”.

Zu fragen, was “neu” eigentlich ist, ist in Zeiten mit viel “Neuem” auf jeden Fall interessant. Und noch spannender ist, das falsch positive vom falsch negativen zu unterscheiden und das ganze zu thematisieren ;)

In this post I will demonstrate some practices to optimize performance and reduce memory footprint of a PHP script. Writing your code according to them is especially useful in the case where you traditionally do not use PHP: transforming a large bulk of data.

Even PHP can handle this because it has become more performant in the last years and has got a command line interface since 4.3.0. But there are more arguments for transforming data with PHP: You reuse your application’s PHP interface. If it is performant itself, it’s probably not necessary to rewrite parts in another language to do the bulk operations.

1. In PHP, assignments copy arrays. Assign arrays explicitly by reference, so they will not be duplicated in memory:

   class RowHolder {
     public $rows;
     function __construct(array $rows) {
       $this->rows = &$rows;
     }
   }
   
   $manyRows = $Stmt->fetchAll();
   $RowHolder = new RowHolder($manyRows);

   Same goes for iteration:

   foreach ($RowHolder->rows as &$row) {
     ...
   }

2. Use prepared statements. Next to be more efficient they prevent SQL injection:

   $Stmt = $PDOConnection->prepare(
     'SELECT * FROM table WHERE id = ?'
   );
   
   foreach ($ids as $id) {
     $row = $Stmt->execute(array($id))->fetch();
     ...
     $Stmt->closeCursor();
   }

3. Check if you really need a class to represent a simple data structure which is used in vast numbers. Memory usage is higher and you get longer serialize() strings. Imagine a country border, which is represented as array of geo points. Using an array of Point objects will need more bytes than simply using an array of arrays, like this:

   $Border = new Geometry(
     Geometry::LinearRing,
     array(
       array(53.0749616,87.867913),
       array(53.0719262,87.840664),
       array(53.0706606,87.819640),
       ...
       array(53.0749616,87.867913)
     )
   );

   I came across this when I created a framework for OpenGIS Simple Features. The standard defines a class hierarchy of geometric features. Starting the conventional way I just transfered it into a big class tree. But then I switched to an easier way, because all classes share an array of elements which form a geometry. I just define the parent class – Geometry. It is a container for a multi-dimensional array instead of a complex object tree.

4. 

   Memory management is still PHP’s big issue. Especially using objects with circular references creates memory leaks. While rendering a website this is not a problem because the number of objects is rather small. Memory is cleaned up after script execution. But looping through millions of objects will make the memory use growing until the script stops (sometimes even without a message). There is no clear way to prevent leaks. Raising memory_limit will not help to complete the script execution, if it will run a long time. I don’t suggest trying to fix memory leaks completely. You will not be successful with complex structures. To create a job script with PHP is not elegant but there is a way to do it.

   I suggest the following solution: Let the script run on the command line until it reaches a memory limit you have defined. If the job was not finished, the script will save its state to a temporary file. On the next execution it reloads the state and starts from there. A bash script repeatedly calls the job script. It looks like this:

   #!/bin/sh
   e=2
   while [ $e -eq 2 ]
     do jobScript.php $1
     e=$?
   done

   And this is a scheme I use for jobScript.php:

   <?php
   ini_set('memory_limit', '500M');
   
   /*
   This one is for checking and should be
   significantly lower than the 'memory_limit' ini setting
   */
   $memory_limit = 100 * 1000 * 1000;
   
   /*
   Create State with names of variables,
   which are important for current execution state.
   Example:
   object identifier of current data row
   */
   $State = new State(array(
     'stateVar1',
     'stateVar2',
     ...
   ), $dataset);
   
   // Try to load variables into script
   if (!$State->load()) {
   
     // On initial execution: init state variables
     $stateVar1 = ...;
     $stateVar2 = ...;
     // On repeated execution: $State->load() does the trick
   }
   
   // This is the loop where your data is transformed
   do {
   
     /*
     The job:
     - fetch data chunk from db depending from state vars ...
     - compute heavy objects (and create memory leaks)
     - put data to db
     - change state vars
     */
   
     /*
     To call
     unset() or explicit __destruct()
     here didn't succeed to prevent memory leaks
     */
   
     if (memory_get_usage(true) > $memory_limit) {
   
       /*
       If memory usage has risen too high,
       save current script state and exit
       */
       $State->save();
       exit(2);
     }
   } while ($data_exists);
   
   /*
   This time the script finishes - now delete
   the script's state and exit with success
   */
   $State->delete();
   exit(0);

   Pretty, huh? For me it has worked many times. This is the State class for download.

   Don’t do this at home, if your job is finished quickly or your script does not create memory leaks ;)

Photos are by photocase users complize and mathias the dread

• faz.net
• sat1.de
• mirror.co.uk
• newsnow.co.uk
• thesun.co.uk
• nydailynews.com
• kn-online.de

Should check your code, guys and learn …

Prinzipiell lässt sich alles auf das Open-Source-Prinzip übertragen, sogar Karten ;)

Seit 2004 gibt es OpenStreetMap: Jeder kann mitmachen und eigene GPS-Tracks hochladen und getaggte Objekte in Form von Wegen, Knoten und Relationen zur freien Datenbank hinzufügen. Das ganze visualisiert und über Open Layers in eine Webseite eingebunden ist teilweise schon konkurrenzfähig zur Standardlösung Google Maps. Soweit klar? – Wie geht das genau?

1. Der “Mapper” steigt mit einem GPS-Gerät auf sein Fahrrad und schaltet die Logging-Funktion des Geräts ein. Damit wird der zurückgelegte Weg festgehalten (”getrackt”).
2. Interssante Punkte (”POI“s) und Informationen markiert er und notiert Infos über die Audio-Aufnahme seines Handys.
3. Er lädt den GPS-Track und die Sound-Dateien auf seinen Rechner und erstellt die Kartendaten mit JOSM. Die GPS-Tracks und Marker werden angezeigt und dienen als Grundlage für die Kartendaten – Wege, Straßen, Wälder, Bäche etc.
4. Zuletzt der Upload via OSM-API auf den Server. Zum Anschauen eignet sich die mit Mapnik gerenderte Karte, die einmal wöchentlich geupdatet wird

Natürlich gibt es andere Methoden zu mappen – aber so habe ich es in den letzten Wochen mit dem Bike gemacht und damit die Höhenstadtteile Triers vervollständigt. Ich sehe in dem Projekt eine Riesenpotenzial, denn die Plattform läuft stabil und die Anzahl der Contributors steigt exponentiell. Nicht nur für Kartendaten ist OpenStreetMap eine super Plattform, sondern für jede Art von Information, die an eine geografische Position geknüpft ist. Auf lange Sicht hat OpenStreetMap eine echte Chance, Dienste, die proprietäre Daten lizenzieren, zu überbieten – vor allem was Details und Aktualität angeht. Alle Daten stehen unter einer Creative-Commons-Lizenz, die Entwicklern keine Hindernisse in den Weg legt.

Rund um das Projekt bilden sich außerdem Communitys von Mappern und Entwicklern. Auch in Trier bildet sich langsam eine Gruppe von Aktiven heraus.

Wer sich noch nie mit Karten befasst hat und gerade nur Bahnhof gelesen hat: Einen guten Überblick verschaffen Wikipedia, das Wiki und die Karte selbst auf openstreetmap.org.

Oder?

That’s because the first principle of the Culture Code is that the only effective way to understand what people truly mean is to ignore what they say. This is not to suggest that people intentionally lie or misrepresent themselves. What it means is that, when asked direct questions about their interests and preferences, people tend to give answers they believe the questioner wants to hear. Again, this is not because they intend to mislead. It is because people respond to these questions with their cortexes, the parts of their brains that control intelligence rather than emotion or instinct. From “The Culture Code”

Mehr zu diesem Thema im Blog von Paul Buchheit

• Finanzierungsoptionen für Software-Startups Am Beispiel des eigenen Software-Projekts Daisho zeigte Klaus Wiedemann, mit welchen Prinzipien man Software und Dienstleistungen an den Mann bringt. Ein paar Punkte:
  • Im Web-Startup-Sektor sind meistens das eigene Konto oder die Einlagen von Verwandten und Freunden die einzige zuverlässige Finanzspritze.
  • Probleme ergeben sich auch dadurch, dass die Konkurrenz durch große Firmen nicht zu unterschätzen ist, der Markt mittlerweile ausgereift ist und oftmals die USA in Sachen Innovation die Nase vorn haben.
  • Die Gegenstrategie von Daisho Blacksmith in den ersten beiden Jahren lag im “opportunistischen Marketing” – das Prinzip mit jeder Art von Arbeit Geld zu machen. Wenn dann genügend Geld zusammen gekommen ist und ein Marktwert aufgebaut ist, kann man sich auf das eigene Feld konzentrieren.
• Um die Themen “kollektive Intelligenz” und “Swarms” drehte sich die interesante Diskussion mit Willi Schroll von Z-punkt. Fazit: Es dreht sich alles um die Frage “Wie wechselwirkt die individuelle mit der kollektiven Intelligenz”? Oder: “Gibt es so etwas wie kollektive Intelligenz überhaupt?” Interessante Beispiele solcher Phänomene finden sich überall: In der Natur in Form von Ameisenstaaten, im WWW in Form von Wikis und freiem Wissen.
• BlogForge – “Das vielleicht beste Blog der Welt!” – So steht es auf der Projektseite des neuen Bloggingtools. Die beiden Entwickler stellten die umfangreichen Features des Blogging Tools vor. Die Stärken liegen vor allem im zugrunde liegendenden PHP-Framework, das es sehr flexibel ermöglicht, über das Backend Änderungen am Datenmodell vorzunehmen. Die Funktionen von BlogForge stellen sich auf einigen stark frequentierten Webseiten unter Beweis.
• Microformats stellte Augustus Kling in einem Vortrag vor. Yahoo berücksichtigt zB bereits eingebettete Definitionen in Suchergebnissen. Mehr zu Microformats gibt es auf microformats.org.
• Die beiden Entwickler Stéphane Becker und Yann Klis vom Barcamp Elsaß stellten vor, wie sie bei der Entwicklung eines Webprojekts vorgehen und welche Prinzipien und Techniken sie verwenden. Stichworte: Extreme Programming, Ruby on Rails, Trac, Unit Testing, Selenium

Das Barcamp hat Spaß gemacht und die Organisatoren um Oliver Gassner haben hervorragende Arbeit geleistet – ich sage danke für das tolle Wochenende! Tag 2 folgt demnächst.