1. Die Evolution des Webs

Das Web enstand 1989 als Projekt am CERN bei Genf (Schweiz), an dem Tim-Berners-Lee ein Hypertext-System aufbaute. Das ursprüngliche Ziel des Systems was es, Forschungsergebnisse auf einfache Art und Weise mit Kollegen auszutauschen. Eine Methode dafür war „Verflechten“ von wissenschafftlichen Artikeln – also das Erstellen eines Webs. In Berners-Lees eigenen Worten:

„The World Wide Web (W3) is a wide-area hypermedie information retrieval initiative aming to give universal acces to a large universe of documents.“

„Das World Wide Web ist eine großräumige Hypermedia-Initiative zur Informationsbeschaffung mit dem Ziel, den allgemeinen Zugang zu einer großen Sammlung von Dokumenten zu erlauben.“

- TIM BERNERS-LEE

Das World Wide Web baut auf einem freien Protokoll auf, was die Entwicklung von Servern und Clients ohne Beschränkungen durch Lizenzen möglich machte. Tim Berners-Lee machte das World Wide Web-Projekt am 6. August 1991 mit einem Beitrag zur Newsgroup alt.hypertext öffentlich und weltweit verfügbar.

1.1 Web 1.0

Anfangs bestand das Web aus einfachen Webseiten, die Informationen lieferten. Diese Dokumente waren zum Anschauen gedacht. Die Webseiten selbst hatten so gut wie keine Interaktion mit dem Besucher der Webseite. Das Web war statisch.

Web 1.0, oder einfach Web, bezieht sich auf die erste Stufe des World Wide Webs seit dessen Veröffentlichung, das Webseiten mittels Hyperlinks verbindet.

Bis zur so genannten Dot-Com-Blase 2001, blieb das Web weitestgehend in dieser Form bestand. Es wurden lediglich etwas mehr Interaktionsmöglichkeiten für Besucher bedacht, etwa Gästebucher auf Webseiten.

Auswahl einiger Web 1.0 Design Elemente:

• Statische Seiten anstelle von Benutzer generiertem Inhalt
• Verwendung von Framesets
• Verwendung von Tabellen zum Positionieren und Ausrichten der Elemente auf der Webseite
• Properitäre HTML-Erweiterungen (z.B.: <marquee>, <blink>)
• Online Gästebucher
• Verwendung von vielen GIF Animationen
• Formulare, die per E-Mail gesendet wurden

1.2 Web 2.0

Nach der Dot-Com-Blase entwickelte sich das Web weiter. Angetrieben von neuen und teilweise auch etwas älteren IT- & Webfirmen rückte der Besucher der Webseite immer mehr in den Vordergrund und wurde schließlich Benutzer.

Abbildung 1: Diese Tagcloud zeigt die Prinzipien des Web 2.0. Sie wurde von Markus Angermeier am 11. November 2005 veröffentlicht.

Der Begriff Web 2.0 grenzt die interaktiven Nutzungsarten vom Web 1.0 ab, in dem es nur wenige „Bearbeiter“ (Personen und Organisationen, die Inhalte für das Web erstellten oder Informationen bereitstellten), aber zahlreiche „Benutzer“ (Konsumenten, welche die bereitgestellten Inhalte passiv nutzten) gegeben habe.

Damit sich Seiten auch von mehreren Menschen effizient bearbeiten und verwalten lassen, sind Content-Management-Systeme und aus Datenbanken gespeiste Systeme entwickelt worden, die während der Laufzeit die Inhalte von Seiten dynamisch austauschen oder neue Inhalte einzusetzen helfen.

Folgende Entwicklungen trugen ab 2005 zur Veränderung des Nutzens des Internets bei:

• Die Trennung von lokal verteilter und zentraler Datenhaltung schwindet.
• Die Trennung lokaler und netzbasierter Anwendungen schwindet.
• Benutzergenierter Inhalt → Webseiten stellen nur noch die Plattform
• Webinhalte verschiedener Dienste werden über offene Programmierschnittstellen nahtlos zu neuen Diensten verbunden.

Neben den technischen Änderungen wurden dabei auch viele neuen Webdienste erschaffen. Tim O’Reilly schrieb am 30. September 2005 einen Artikel, der dieses Thema grundlegend erklärt. Abbildung 1 zeigt in einer Tagcloud die Prinzipien des Web 2.0.

1.3 Vergleich Web 1.0 & Web 2.0

Tim O’Reilly definierte den Begriff Web 2.0 im Jahr 2006. Er beschrieb Web 2.0 als eine Veränderung in der Geschäftswelt und als eine neue Bewegung in der Computerindustrie hin zum Internt als Plattform.

O’Reily beschrieb somit den grundlegenden Wechsel einer Internetseite von einem festen, statischen Dokument hin zu einer Plattform. Der Inhalt stammt nicht mehr vom Webmaster selbst, sondern kommt von den Benutzern der Webseite. Abbildung 2 verdeutlicht dies noch ein Mal anschaulich.

Abbildung 2: Vergleich Web 1.0 vs. Web 2.0 (Quelle)

Web 3.0

Ein Problem des heutigen Internets ist die riesige Datenmenge, die für jedermann zugänglich ist. Das Web weiß aber nicht, was es damit anfangen kann, um uns die tägliche Arbeit zu erleichtern. Das Web hat somit nicht mehr als einen Speicher (Gedächtnis), ohne es mit Logik und Weitsicht verbinden zu können. Das Web ist „dumm“.

Eine Änderung muss her. Von den reinen Dokumenten, die bisher im Internet zugänglich sind müssen diese eine Bedeutung (Semantik) bekommen. Von daher spricht man von Web 3.0 auch vom sematischen Web.

Das semantische Web ist eine Instanz von Semantischen Netzen. Als Instanz ist das Semantische Web außerdem eine Erweiterung des World Wide Web. Ziel des Semantischen Webs ist es, die Bedeutung von Informationen für Computer verwertbar zu machen und damit automatisch für die interessierten Nutzer im Zuge einer Abfrage zu ordnen. Die Information im Web sollen von Maschinen interpretiert und automatisch weiterverarbeitet werden können. Informationen über Orte, Personen und Dinge sollen mit Hilfe des Semantischen Webs auf der Basis der Inhalte miteinander in Beziehung gesetzten werden können.

Während das World Wide Web eine Möglichkeit darstellt, Daten miteinander zu vernetzen, zeigt das Sematic Web einen Weg auf, Informationen auf der Ebene ihrer Bedeutung miteinander zu verknüpfen.

Eine Möglichkeit zur Lösung dieses Problems zeigt das Konzept der Wissensrepräsentation – auch als Knowledge Representation bezeichnet.

Die Wissenrepräsentation setzt sich aus drei Bereichen anderer wissenschaftlicher Felder zusammen:

• Logik stellt die formale Struktur bereit, um Regeln zu formulieren, mit deren Hilfe das Computersystem Rückschlüsse bilden kann.
• Ontologien definieren die Objekte, die einem bestimmten Umfeld existieren.
• Berechenbarkeit ist eine Eigenschaft einer Wissensbasis, die diese praxistauglich werden lässt.

Das Web von heute sind Dokumente, während das Web von morgen, das sematische Web, Dinge sind. Das Web erkennt Personen, Orte, Veranstaltungen, Unternehmen, Produkte, Filme, etc… und es versteht die Beziehung zwischen den Daten. Semantik wird in der Informatik als Bedeutung hinter den Daten bezeichnet. Deswegen auch das semantische Web genannt.

In Anlehnung an den Begriff Web 2.0 spricht man nach John Markoff von Web 3.0, wenn zu den Konzepten des Web 2.0 noch die Konzepte des semantischen Web hinzukommen.

2. Grundbausteine des Web 3.0

Der Begriff „Sematic Web“ bezieht sich auf die Vision des World Wide Web Consortiums (W3C) des „Webs of Linked Data“. Die Sematic Web Technologien sollen das Ziel ermöglichen, Computern mehr nützliche Arbeit aufzutragen und Systeme zu erstellen, die eine vertrauenswürdige Interaktion im Netzwerk bereitstellen. Um dies zu ermöglichen, werden zu den Linked Data, Vocabularies erschaffen. Querys können diese Daten abfangen und durch so genannten Inference auch schlussfolgert werden.

2.1 Linked Data

Die Idee offener vernetzter Daten sind sätmliche Datenbestände, die im Interesse der Allgemeinheit der Gesellschafft ohne jedwede Einschränkung zur freien Nutzung, zu Weiterverbreitung und zu freien Weiterverwendung frei zugänglich gemacht und über das World Wide Web miteinander vernetzt sind.

Während das WWW ein Netzt aus Webseiten ist, soll mit Linked Data ein Netz aus Daten entstehen, die aus verschiedenen Quellen zusammen automatisch weiterverwendet werden können. Das Konzept von Linked Data geht im Wesentlichen auf Tim Berners Lee zurück, der auch Ende 2007 die Bezeichnung „Giant Global Graph“ (GGG) vorschlug. Er prägte vier Regeln für Linked Data:

„1. Verwende zur Bezeichnung von Objekten URIs
2. Verwende HTTP URIs, so dass sich die Bezeichnungen nachschlagen lassen
3. Stelle zweckdienliche Informationen bereit, wenn jemand eine URI nachschlägt (mittels Standards)
4. Zu diesen Informationen gehören insbesondere Links auf andere URIs, über die weitere Objekteenteckt werden können.“

– TIM BERNERS-LEE (Quelle)

Tim Berners-Lee on the next Web (Quelle)

Zu den Komponenten von Linked Data zählen also URIs, HTTP, das Resource Description Format (RDF) als Standarisierung, und Serilalization Formate (RDFa, RDF/XML, …), um Daten abzurufen.

Ein Beispiel für Linked Data ist DBpedia, welches die Inhalte (Daten) aus Wikipedia extrahiert und den Benutzern erlaubt Beziehungen und Eigenschaften der Daten anzugeben. Mittlerweile beschreibt DBpedia mehr als 3.64 Millionen Dinge (siehe Abbildung 3).

Abbildung 3: Verknüpfung zwischen Linked Open Data Datenbeständen (Juli 2009) (Quelle)

2.2 Vocabularies

Im semantischen Web definieren Vocabularies Konzepte und Beziehungen (auch „term“ genannt) der einzelnen Daten. Vocabularies werden verwendet, um den Daten mögliche Beziehungen und Charakterisierungen zu definieren und behalten auch mögliche Einschränkungen vor. In der Praxis werden Vocabularies sehr komplex sein (mit mehreren Tausend Begriffen) oder einfach (mit ein oder zwei Begriffen).

In der Informatik wird Vocabulary (vom W3C definiert) auch als Ontologie bezeichnet. Wikipedia beschreibt Ontologie so:

„Ontologien in der Informatik sind meist sprachlich gefasste und formal geordnete Darstellungen einer Menge von Begrifflichkeiten und der zwischen ihnen bestehenden Beziehungen in einem bestimmten Gegenstandsbereich. Sie werden dazu genutzt, „Wissen“ in digitalisierter und formaler Form zwischen Anwendungsprogrammen und Diensten auszutauschen. Wissen umfasst dabei sowohl Allgemeinwissen als auch Wissen über sehr spezielle Themengebiete und Vorgänge.“

Vocabularies werden also verwendet, um die miteinander verknüpften Daten (Linked Data) zu beschreiben und ihnen einen Sinn zu geben.

2.3 Query

„Query“ im semantischen Web, sind Technologien und Protokolle, die automatisch Information aus dem „Web of Data“ abrufen können. Genauso wie strukturierte Datenbanksysteme Querys benutzen, um Informationen abzurufen, braucht das semantische Web ebenfalls Querys, um die Beziehungen und Eigenschaften einer Anfrage zu verarbeiten und zurückzuliefern.

Vom World Wide Web Consortium wurde 2011 die „SPARQLquery language“ als Standard fürs semantische Web herausgebracht. Diese Technologie soll bis zur Verarbschiedung des Standards für die Aufbereitung und Abrufen der Daten im semantischen Web verwendet werden. Die Kommunikation erfolgt entweder über das Hypertext Transfer Protocol (HTTP) oder über Simple Object Asses Protocol (SOAP).

2.4 Inference

Inference, zu deutsch etwa „Schlussfolgerung“, soll auf Grundlage von erstellen Vocabularies und Linked Data, völlig automatisch neue Beziehungen und Charakterisierungen aufstellen. Es soll wie der Name bereits propagiert „schlussfolgern“.

Diese Schlussfolgerungen sollen ebenfalls auch wichtig zur Entdeckung von Inkonsistenzen in den breits vorhandenen (integrierten) Daten sein.

Mit Inference und den bereits angesprochenen Linked Data und Vocabularies wird das Web dann tatsächlich zum denken Web, das sein Wissen auch tatsächlich selbständig nutzen kann.

Als weiterer Grundbaustein des Web 3.0 sei noch so genannte „Vertical Applications“ angesprochen. Dies sind Forschungsgruppen die in Zusammenarbeit mit dem World Wide Web Consortium das Semantic Web „erforschen“ und auf Grundlage ihrer Ergebnisse diese als neue Webstandards beschließt.

3. Realisierung auf der eigenen Webseite

Um bereits heute seine eigene Webseite semantisch aufzubereiten, gibt es mehrere Möglichkeiten. Im folgenden möchte ich kurz die drei am häufigsten verwendeten aufzeigen und diese kurz erläutern.

3.1 RDFa (Resource Description Framework – in – attributes)

Das Resource Description Framework (RDF) bezeichnet eine Familie von Standards des World Wide Web Consortiums (W3C) zur formalen Beschreibung von Information über Objekte, sogenannte Ressource, die durch eindeutige Bezeichner (URIs) identifiziert werden.

Im wesentlichen stellt RDFa eine Reihe von Attributen, mit denen Metadaten in eine XML-Sprache überführt werden, bereit.

Diese Attribute sind:

• about & src: URI oder CURIE Angabe über die Quelle
• rel & rev: Angabe einer Beziehung oder umgekehrte Beziehung mit einer anderen Ressource
• href & resource: Angabe der Partner-Ressource
• property: Angabe einer Eigenschaft für den Inhalt des Elements
• content: optionales Attribut, das den Inhalt des Elements überschreibt
• datatype: optionales Attribut, das den Datentyp spezifiziert
• typeof: optionales Attribut, spezifiziert den RDF Typ des Titels

Beispiel:

<p xmlns:dc="http://purl.org/dc/elements/1.1/" about="http://www.example.com/books/wikinomics">
In his latest book <cite property="dc:title">Wikinomics</cite>, <span property="dc:creator">Don Tapscott</span> explains deep changes in technology, demographics and business. The book is due to be published in <span property="dc:date" content="2006-10-01">October 2006</span>.
</p>

Beispiel 1: RDFa Beispiel

3.2 Microformat

Mikroformate sind ein Markup-Format zur semantischen Annotation von HTML oder XHML. Mikroformat-Annotationen können leicht aus Webseiten extrahiert werden und machen weiteren Programmen (etwa Suchmaschinen) die Bedeutung des Seiteninhalts verständlich.

Jedes Mikroformat wurde für ein spezielles Themen- oder Wissensgebiet entwickelt. So gibt es Mikroformate für Termine, für Kontaktinformationen und für soziale Beziehungen.

Die bisher vorhanden (X)HTML-Standards erlauben minimale semantische Annotationen durch folgenden Attribute:

• class: Klassenname
• rel: (von relationship) Vorwärtsbeziehung in einem anchor-Element (<a>), Beschreibung der Zieladresse
• rev: (von reverse relationship) Rückwärtsbeziehung, Gegenteil der Vorwärtsbeziehung, Beschreibung des referenzierenden Dokuments

Folgendes Beispeil ist mit dem Mikroformat hCard ausgezeichnet:

<div class="vcard">
<div class="fn">Max Mustermann</div>
<div class="org">Musterfirma</div>
<div class="tel">01234/56789</div>
<a class="url" href="http://example.com/">http://example.com/</a>
</div>

Beispiel 2: Mikroformat Beispiel

Die Klassen beschreiben folgendes:

• fn: formatted name
• org: Organisation
• tel: Telephone
• url: Homepage

3.3 Microdata

Diese Spezifikation versucht, das Einbinden maschinenlesbarer Informationen in HTML-Dokumenten zu definieren. Ziel dabei ist, dass dieser Mechanismus eindeutig definiert und zu anderen Formaten wie RDF und JSON kompatibel ist.

Globale Microdata Attribute:

• itemscope: Erzeugt das Item und zeigt an, dass Nachkommen von diesem Element Informationen über dieses enthalten.
• itemtype: Eine valide URL zu einem Vocabulary, dass das Item und seinen Inhalt beschreibt.
• itemid: Gibt einen einzigartige ID für das Item an.
• itemprop: Zeigt an, dass mithilfe des Tags das Element die Eigenschaften des Tags enthält.
• itemref: Eigenschaften, die nicht Nachkommen des Elements mit dem itemscope Attributs sind, kann mit diesem Attribut zugeordnet werden. Enthält außerdem eine Liste der IDs der Elemente mit zusätzlichen Eigenschaften an anderer Stelle im Dokument.

Beispiel:

<section itemscope itemtype="http://data-vocabulary.org/Person">
Hello, my name is <span itemprop="name">John Doe</span>, I am a <span itemprop="title">graduate research assistant</span> at the <span itemprop="affiliation">University of Dreams</span>. My friends call me <span itemprop="nickname">Johnny</span>. You can visit my homepage at <a href="http://www.JohnnyD.com" itemprop="url">www.JohnnyD.com</a>.

<section itemprop="address" itemscope itemtype="http://data-vocabulary.org/Address">
I live at <span itemprop="street-address">1234 Peach Drive</span> <span itemprop="locality">Warner Robins</span>, <span itemprop="region">Georgia</span>.
</section>
</section>

Beispiel 3: Microdata Beispiel (HTML5-Spezifikation)

Google würde das obige Beispiel folgend interpretieren:

Item
    Type: http://data-vocabulary.org/Person
    name = John Doe
    title = graduate research assistant
    affiliation = University of Dreams
    nickname = Johnny
    url = http://www.johnnyd.com/
    address = Item(1)
Item 1
    Type: http://data-vocabulary.org/Address
    street-address = 1234 Peach Drive
    locality = Warner Robins
    region = Georgia

Beispiel 4: Google Interpretation von Beispiel 3

4. Beispiele

Im folgenden wird versucht anhand von drei Beispielen Web 3.0 in der Praxis zu zeigen, vorab sollte erwähnt werden, dass das semantische Web immer noch Gegenstand der Forschung ist.

4.1 GroupMe!

An dieser Stelle wird eine Anwendung präsentiert, die eine neue Art vom sozialen Tagging System darstellt. Die Anwendung heißt GroupMe! und verbindet neben Web 2.0 Ansätze von Semantic Web Technologien.

Die neuartige Web 2.0”-Anwendung GroupMe!” fasst multimediale Webinhalte in Themengruppen zusammen. Durch seine innovative Benutzeroberfläche und den Einsatz von Semantic-Web-Technologien bietet GroupMe!” neue Möglichkeiten, Informationen zu erschliessen. Die neue Gruppenstruktur und semantische Annotationen verbessern die zielgerichtete Suche nach Inhalten.

Die Anwendung basiert auf einer einfachen Idee, die den Benutzern erlaubt Web Ressourcen zu gruppieren. Also eine der wichtigsten Funktionen ist die Erstellung von Gruppen von Multimedia Web Ressourcen mit Drag and Drop. Den Benutzern ist eine gewisse Freiheit überlassen die Gruppen nach eigenen Wünschen zu formatieren und zu strukturieren, basierend auf dem Konzept von Mind Maps. Der Sinn der Sache ist, dass sehr viele relevante Ressourcen in Gruppen zusammengefasst werden. Die Gruppen stellen ver-
schiedene Themenbereiche dar. Innerhalb der Anwendung ist den Benutzern die Suche von Ressourcen von anderen Benutzern selbstverständlich gestattet. Eine eigene API steht den Benutzern zur Verfügung und bietet die Möglichkeit die Anwendung mit weiteren Funktionen zu erweitern.

Ein Überblick über die Möglichkeiten und Funktionen von GroupMe wird im Bild (Abbildung 4) dargestellt.

Abbildung 4: Aufbau von GroupMe!

Eine GroupMe!”-Gruppe ist eine thematische Sammlung von Links, die auf relevante Webseiten, Bilder und Videos verweisen. Ein wichtiger Unterschied zu gewöhnlichen Linksammlungen ist die graphische Darstellung der Links und Gruppen. Links werden dem Medientyp entsprechend visualisiert: Bilder und Videos können direkt in der Gruppe betrachtet werden, bei News-Feeds, wie Informationen aus Blogs, werden aktuelle Schlagzeilen angezeigt, und Musikdateien können direkt abgespielt werden. Durch diese Form der Visualisierung bekommt der Betrachter einer Gruppe einen sofortigen Überblick über das Thema und seinen Inhalt. Mit dem GroupMe!-System können Web-Inhalte somit effizienter erfasst und verwaltet werden als mit traditionellen Wissensmanagement-Systemen.

4.2 RelFinder

RelFinder ermöglicht eine wunderbar visualisierte Form der Beziehungen zwischen einzelnen Objekten. Es extrahiert und visualisiert Beziehungen zwischen bestimmten Objekten in Datensätzen und macht diese Zusammenhänge interaktiv erforschbar. Highlighting und Filterfunktionen unterstützen die Analyse sowohl auf globaler und auf detaillierten Ebene.

RelFinder basiert auf dem Open-Source-Framework Adobe Flex, das einfach zu bedienen ist und funktioniert mit allen RDF Daten, die standardisierte SPARQL Zugang zur Verfügung stellen.

Abbildung 5: Visualisierung der Beziehungen von semantischen Daten: RelFinder

4.3 THESEUS

THESEUS ist ein vom Bundesministerium für Wirtschaft und Technologie (BMWi) initiiertes Forschungsprogramm mit dem Ziel, den Zugang zu Informationen zu vereinfachen, Daten zu neuem Wissen zu vernetzen und die Grundlage für die Entwicklung neuer Dienstleistungen im Internet zu schaffen.

Im Fokus des Forschungsprogramms stehen semantische Technologien, die Inhalte (Wörter, Bilder, Töne) nicht mit Hilfe herkömmlicher Verfahren (z. B. Buchstabenkombinationen) ermitteln, sondern die inhaltliche Bedeutung von Informationen erkennen und einordnen können. Mit diesen Technologien sollen Computerprogramme besser nachvollziehen können, in welchem Kontext Daten abgespeichert wurden. Darüber hinaus können Computer aus den Inhalten logische Schlüsse ziehen und selbständig Zusammenhänge zwischen unterschiedlichen Informationen aus mehreren Quellen erkennen und herstellen. Mit diesen Technologien schafft Theseus die Grundlage für neuartige Produkte, Werkzeuge, Dienste und Geschäftsmodelle für das Internet der Dienste. Das Forschungsprogramm leistet damit wichtige Beiträge zu zwei aktuellen Entwicklungen in der Informations- und Kommunikationstechnologie (IKT):

1. Die Schaffung eines „Internet der Dienste“, einer „Marktplattform, auf der künftig Serviceleistungen wie Güter handelbar und auf der Grundlage semantischer Technologien und serviceorientierter Architekturen beliebig kombinierbar“ sind
2. Das Vorantreiben des lernfähigen „Web 3.0“, welches laut Wolfgang Wahlster (DFKI GmbH) durch seine semantischen Verknüpfungen dem Endnutzer auf eine Anfrage „direkt eine präzise Antwort“ liefern soll

Die Basistechnologien werden in den sechs Anwendungsszenarien Alexandria, Contentus, Medico, Ordo, Processus, Texo exemplarisch auf ihre Nutzbarkeit hin aufbereitet und getestet.

5. Vor- und Nachteile des Web 3.0

Nachfolgend werden Vor- und Nachteile des semantischen Web aufgezählt und erläutert. Da das Web 3.0 noch kein fester Standard ist, oder wird, können die aufgezählten Punkte in Zukunft revidiert werden.

5.1 Vorteile

Das Internet setzt sich aus einer überwältigenden Menge von Webseiten, Texten, Bildern, Videos, Dokumenten – kurz Ressourcen zusammen, die jeweils uber eine eindeutige Adresse, die URL auffindbar sind. Eine bessere Ordnung in dieses Ressourcenuniversum zu bringen ist eine zentrale Hoffnung, die mit Semantic-Web-Technologien verbunden ist.

Eine der Ziele von Semantic Web ist die Wiederverwendung von Wissen über sprachliche Barrieren hinweg, die wiederum eine aggregierte Suche über mehrere Seiten erlauben sollte. Durch den Einsatz von Techniken der künstlichen Inteligenz soll die Qualität der Suche verbessert werden, indem die Fehler und Wiedersprüche identifiziert und eliminiert werden.

Weitere Vorteile des semantischen Webs sind:

• digitale Signaturen: Die Herkunft einer Information lässt sich eindeutig nachweisen. Entsprechende Programme könnten also die Glaubwürdigkeit einer Information abschätzen. So kann das Vertrauen der Nutzer in die gewonnenen Informationen gestärkt werden. Ebenfalls ist denkbar, dass, gestützt auf diese glaubwürdigen Daten, die Zusammenarbeit im Unternehmen und von Unternehmen durch das Semantic Web ausgeweitet werden kann.
• Verkettung von Diensten: Einzelne Dienste (z.B. bestimmte Suchmaschinen oder spezialisierte Datenbanken) könnten ihre Serviceleistungen über entsprechende semantische Strukturen anpreisen, so dass ein Computer sie auslesen und ihren Nutzen abschätzen kann. Anschließend könnte er für eine beliebige Anfrage eine passende Kette zusammenstellen, in der er eine grosse Anzahl von Informationen durch verschiedene Dienste schickt und dem Nutzer anschließend nicht eine unüberschaubare Vielzahl von Links gibt, sondern nur die Informationen nennt, die wirklich alle Filter durchlaufen haben. Die gezielte Auffindung von Informationen wird also stark verbessert.
• Automation: Wenn alle Geräte über entsprechende Datenbanken verkettet sind, lassen sie sich einfach automatisieren. Hierzu ein Beispiel: Ein Nutzer hört laute Musik, als das Telefon klingelt. Praktisch wäre es, wenn sich die Musik automatisch leise drehen würde, sobald er den Hörer abhebt, und wieder lauter wird, wenn das Gespräch beendet ist. Mit semantischen Strukturen ist so etwas nicht nur möglich, sondern auch einfach: Ein Nutzer muss jetzt nämlich nicht mehr seinen Computer so einstellen, dass er leiser wird, wenn das Telefon klingelt; und dann seinen Fernseher so einstellen, dass er leiser wird, wenn das Telefon klingelt; und dann seinen DVD-Spieler so einstellen, dass… sondern alle Geräte, die über die Information Lautstärke kann geregelt werden verfügen, werden automatisch leiser, wenn das Telefon klingelt.

5.2 Nachteile

Obwohl das Semantic Web bereits seit vielen Jahren propagiert wird, ist bisher nur in einzelnen Vorzeige-Projekten eine Realisierung zu erkennen. Die vorgestellten Semantic-Web-Standards sind zwar technisch gesehen Standards, aber noch weit davon entfernt, durch verbreiteten Gebrauch faktisch akzeptierte Standards darzustellen. In der Praxis ergeben sich erhebliche Probleme. Sie reichen von der Frage, wie detailliert man semantische Relationen modellieren soll, will oder kann, bis hin zur politischen Überlegung, ob es Autoritäten geben soll, die zentrale Bedeutungen festlegen. Zunächst bedeutet die zusätzliche Anreicherung von Daten mit maschinenlesbaren Informationen auch zusätzliche Arbeit. Redakteure müssen neben der Erstellung des Artikels auch noch für die korrekte Verschlagwortung sorgen.

Die Konzepte des Semantic Web sind hochkomplexe Formalismen. Das bleiben sie selbst dann, wenn es gelinge, eine intuitive Anwendung zu entwickeln. In erster Linie bleibt der Aufbau semantischer Netze damit Experten vorbehalten. Stärker noch als Enzyklopädien definieren semantische Netze, was die Welt ist, was wahr ist und was falsch. Damit kommt einer sehr kleinen Gruppe von Menschen eine ausgesprochen große Definitionsmacht zu.

Eine alternative Herangehensweise stellen Social-Tagging-Systeme dar, die genutzt werden können, um aus einer groen Menge von individuell vergebenen Schlagwörtern dezentrale Onthologien (Folksonomies) aufzubauen. Daraus ergibt sich allerdings das umgekehrte Problem: Was einen Tag ausmacht wird über den Mittelwert der Masse aller, die Objekte mit diesem Tag versehen haben, definiert. Doch gibt es reichlich Beispiele für populäre Irrt ̈mer. Die Popularität von Tagging in diversen Web 2.0 Anwendungen macht dennoch Hoffnung, dass zwei Grundannahmen des Semantic Web richtig sind: Zum Einen geben sich viele Nutzer Mühe, Daten mit semantisch korrekten Metadaten anzureichern. Zum Anderen scheinen sich Tags als sinnvolle und verständliche Suchmöglichkeit neben der Volltextsuche etabliert zu haben.

Auch der Datenschutz spielt eine immense Rolle. Was wäre wenn es Hackern gelingen würde das intelligente Web zu manipulieren? Es sozusagen für ihre Zwecke missbrauchen und anderen damit schaden. Für solche Fragen müssen definitiv noch viele Sicherheitsmechanismen aufgebaut werden, die dann auch greifen müssen.

Und zu guter Letzt noch ein entscheidener Punkt. Will ich wirklich vom World Wide Web bemuttert werden? Wenn das Web immer glaubt zu wissen was ich derzeit brauche, hat dies wirklich nur Vorteile? Wenn ich in einer Suchanfrage nur eine passende Antwort bekomme reicht mir das? Oder will ich nicht lieber vergleichen und selber nachdenken was für mich richtig ist.

6. Fazit

Der Begriff Web 3.0, ist nicht mehr wie ein Begriff. Er ist kein festegschriebener Standard o.ä. sondern bringt eine Reihe neuer Standards mit sich. Diese befinden sich aktuell alle noch in der Entwicklung. Das semantische Web wird frühestens 2018 als Standard verabschiedet.

Mit dem Web 3.0 soll das Word Wide Web vom Dokumenten-Web zum „Web of Data“ weiterentwickelt werden. Grundsätzlich sind nicht mehr die einzelnen HTML-Dokumente entscheidend, sondern die darin befindliche Bedeutung und die Beziehungen zwischen einander. Das Web wird somit intelligent und kann sein rießiges Gedächtnis auch wirklich nutzen.

Ein Grund für die zögerliche Paketierung könnte sein, dass Eclipse bereits eine interne Paketverwaltung mitbringt, über die Plugins mittels Paketquellen installiert werden können. Eventuell haben wenige Leute Interesse daran Eclipse zu paketieren. Deshalb bin ich dazu übergegangen mir selbst ein eigenes Eclipse Paket zu bauen, und dieses über APT zu installieren. Wie das ganze funktioniert, beschreibe ich hier.

Vorbereiten und Erstellen des Arbeitsverzeichnisses

Bevor wir mit der Paketierung starten können, benötigen wir noch einige Pakete und ein Arbeitsverzeichnis, in dem wir später unser Eclipse Paket bauen werden.

$ sudo apt-get install fakeroot dpkg-dev debhelper unp

Hiermit werden einige Tools installiert, die wir benötigen um die entsprechenden Rechte des Pakets zu setzen und dieses schlussendlich zu bauen.

$ mkdir eclipse-sdk

Innerhalb dieses Arbeitsverzeichnisses müssen nun die Ordner so angelegt werden, wie sie später auf dem Dateisystem abgebildet werden sollen. Legt man also innerhalb dieses Ordners eclipse-sdk den Ordner bin an und speichert dort Dateien, so werden diese Dateien später nach /bin installiert. Userprogramme werden unter Linux üblicherweise unter /usr installiert. Ich lasse den Inhalt des Archivs nach /usr/lib/eclipse installieren.

Eclipse herunterladen und Paket vorbereiten

Ich installiere mir das Eclipse SDK, also mit bereits installierten JAVA Development Tools und in der 64-Bit Variante. Wer eine andere Version braucht, sollte dies anpassen.

$ wget http://download.eclipse.org/eclipse/downloads/drops/R-3.7.1-201109091335/download.php?dropFile=eclipse-SDK-3.7.1-linux-gtk-x86_64.tar.gz
$ unp eclipse-platform-3.6.2-linux-gtk-x86_64.tar.gz
$ mkdir -p eclipse-sdk/usr/lib
$ mv eclipse eclipse-sdk/usr/lib/eclipse

Anschließen erstellen wir ein Skript, mit dem wir Eclipse starten können. Startskripte werden in /usr/bin abgespeichert.

$ mkdir -p eclipse-sdk/usr/bin
$ touch eclipse-sdk/usr/bin/eclipse
$ chmod +x eclipse-sdk/usr/bin/eclipse

Mit dem zweiten Befehl erstellen wir eine leere Datei und geben dieser mit dem dritten Befehl Ausführrechte. Nun sollten wir dem Startskript natürlich auch einen Inhalt geben. Dies kann entweder mit einem Konsolen-Editor geschehen (wie vi oder nano) oder auch mit einem grafischen Editor (z.B. gedit, …). Folgenden Inhalt bekommt unser Startskript:

#!/bin/sh
exec /usr/lib/eclipse/eclipse "$@"

“$@” bewirkt, dass dem Skript mitgegebene Parameter an Eclipse weitergereicht werden. Nun müssen wir noch einen Menüeintrag erstellen, so dass sich Eclipse auch bequem aus dem Anwendungsmenü heraus starten lässt.

$ mkdir -p eclipse-sdk/usr/share/applications
$ nano eclipse-sdk/usr/share/applications/eclipse.desktop

[Desktop Entry]
Encoding=UTF-8
Type=Application
Name=Eclipse
Exec=eclipse
Terminal=false
Icon=/usr/lib/eclipse/icon.xpm
Comment=Eclipse Integrated Development Environment
Categories=Development;IDE;

Nun haben wir also ein Startskript, einen Anwendungsstarter sowie einen Programmordner. Fehlen nur noch Informationen, die das Paket näher beschreiben, damit auch APT was damit anfangen kann.

Paketinformationen und paketieren

Wir brauchen für die Paketierung eine Debain Control Datei. Die das Paket näher beschreibt und Abhängigkeiten auflistet.

mkdir eclipse-sdk/DEBIAN
nano eclipse-sdk/DEBIAN/control

In die Control Datei kommt folgender Inhalt:

Package: eclipse-sdk
Version: 3.7.1
Architecture: amd64
Maintainer: InsertYourNameHere
Depends: openjdk-6-jre | sun-java6-jre
Section: devel
Priority: optional
Description: Eclipse IDE, static-linked, minimal plugins.

Als Maintainer sollte euer Name stehen. Die Abhängigkeiten die Eclipse benötigt sind Java. Egal ob dies OpenJDK oder doch Sun Java ist. Alles andere ist bei Eclipse dabei.

Nun verpacken wir das Paket und können dies dann ganz bequem installieren.

$ fakeroot dpkg -b eclipse-sdk eclipse-sdk_3.7.1_amd64.deb
$ sudo dpkg -i eclipse-sdk_3.7.1_amd64.deb

Wenn fakeroot nicht vergessen wurde (wird benötigt um die Rechte richtig zu setzen!) sollte Eclipse jetzt problemlos starten.

Getestet mit Ubuntu 11.10 und Ubuntu 11.04.

Bei näherem Untersuchen des Problems stellt sich heraus, das diese Dateien auch nicht für 64-Bit Systeme gedacht sind sondern für “normale” 32-Bit Systeme. Also erstmal versucht auf der Webseite von Veetle bzw. deren FTP-Servern eine andere Version zu finden, doch leider alles ohne Erfolg. Ich hab dennoch nicht aufgegeben. Stundenlanges Suchen sowie tausende Foren und Blogeinträge später hatte ich mein Ergebnis. Irgendwer hatte noch eine sogenannte Plus Version von Veetle, die auf 64-Bit Rechnern funktionieren soll.

Und tatsächlich, das hat geklappt. Also für alle hier der Download, nachdem ihr das Archiv heruntergeladen und (2x) entpackt habt, beschreib ich kurz wie das ganze installiert wird.

1. Terminal öffnen
2. mkdir -p ~/.mozilla/plugins
3. cp *.so ~/.mozilla/plugins
4. mkdir -p ~/.veetle_vlc
5. cp vlc vlcori ~/.veetle_vlc

Wenn ihr dann euren Browser öffnet unter about:plugins und euch folgende neuen Plugins begrüßen, habt ihr Veetle erfolgreich installiert. Testen könnt ihr das ganze dann natürlich unter www.veetle.com.

Installiertes Veetle Plugin unter Google Chrome auf einem 64-Bit Ubuntu

Ein paar Worte zu Beginn

Warum überhaupt ein ganzes Tutorial, mehr als einwenig Javascript und Python Code ist das ganze ja nicht. Eigentlich ja, jedoch gibt es genau dort ein kleines Problem. Django’s Authentifizierungssystem gibt bei jeder Server Anfrage den Session-Token via Browser Cookie weiter. SWFUpload hingegen sendet den sessionid Cookie nicht weiter. Somit sieht Django im View nur das request.user ein AnonymousUser ist, egal ob der Uploader authentifiziert war oder nicht.

Um das Problem zu beheben benötigen wir das SWFUpload Cookie Plugin, was nicht mehr als ein wenig JavaScript Code ist, welcher die aktuellen Cookies hinzufügt. Dann werden wir eine Middleware in Django schreiben welche uns den Session Token extrahiert und zurück zu request.COOKIES schreibt.

Vorbereitung

Ich zeige das ganze Vorgehen nun bei dem Beispiel einer (einfachen) Bildergalerie in Django und ich gehe davon aus das euer Webserver statische Dateien wie in settings.MEDIA_ROOT ausliefert und diese im Web via settings.MEDIA_URL zugänglich macht (siehe Django Dokumentation).

Zuerst einmal unser Model in gallery.models

from django.db import Models
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import User
from tagging.fields import TagField
from tagging.models import Tag
from category.models import Category

def get_image_path(instance, filename):
    '''
        Create dynamic image upload path for every gallery
    '''
    return 'gallery/%s/%s' % (str(instance.album.slug), filename)

class Album(models.Model):
    '''
        Model for an gallery
    '''
    name = models.CharField(max_length=150, verbose_name=_('Name'))
    slug = models.SlugField(max_length=150, unique=True)
    content = models.TextField(verbose_name=_('Beschreibung'), blank=True, null=True)

    user = models.ForeinKey(User, related_name='user')
    category = models.ForeignKey(Category, related_name='category', verbose_name=_('Kategorie')

    def __unicode__(self):
        return self.name

    @models.permalink
    def get_absolute_url(self):
        return 'gallery_detail', (), {'slug': self.slug}

    class Meta:
        verbose_name = _(u'Fotoalbum')
        verbose_name_plural = _(u'Fotoalben')

class Picture(models.Model):
    '''
        Model for images. Every Image must have a gallery.
    '''
    album = models.ForeignKey(Album, related_name='album')

    image = models.ImageField(max_length=180, upload_to=get_image_path, verbose_name=_('Bild'))
    content = models.TextField(verbose_name=_('Beschreibung'), blank=True, null=True)
    tags = TagField()

    def set_tags(self, tags):
        Tag.objects.update_tags(self, tags)

    def get_tags(self, tags):
        return Tag.objects.get_for_object(self)

    def __unicode__(self):
        return '%s Picture #%d'% (self.album.name, self.id)

    class Meta:
        verbose_name = _(u'Foto')
        verbose_name_plural = _(u'Fotos')

Nun gehen wir davon aus, das in unser View per gallery_add erreicht wird. Will heißen in der urls.py wird der view mit diesem Name versehen. Bevor wir uns jedoch um den View kümmern integrieren wir erst einmal SWFUpload ins Template (bei mir gallery/add.html). Also zunächst einmal das Core Package von SWFUpload downloaden, Archiv entpacken und die Dateien Flash/swfupload.swf, swfupload.js und plugins/swfupload.cookies.js ins settings.MEDIA_ROOT Verzeichnis verschieben. Im Template selbst nun die JavaScript Dateien einfügen.

SWFUpload integrieren

Der nächste Schritt ist SWFUpload mit ein klein bißchen JavaScript verfügbar zu machen. In der Dokumentation von SWFUpload ist vieles weitaus ausführlicher beschrieben, wie ich das hier mache, ich beschränke mich auf wesentliche.

var swfu;

    SWFUpload.onload = function () {
        var settings = {
            flash_url: '{{ MEDIA_URL }}swfupload.swf',
            upload_url: '{% url gallery_add slug=slug %}',
            file_size_limit: '10 MB',
            file_types: '*.*',
            file_types_description: 'Bilddateien',
            file_upload_limit: 100,
            file_queue_limit: 0,
            custom_settings: {
                progressTarget : 'fsUploadProgress',
                cancelButtonId : 'btnCancel'
            },
            post_params: {
                'csrfmiddlewaretoken': '{{ csrf_token }}',
                'slug': '{{ slug }}'
            },
            debug: false,

            // Button Settings
            button_placeholder_id: "spanButtonPlaceholder",
            button_width: 128,
            button_height: 30,
            button_window_mode: SWFUpload.WINDOW_MODE.TRANSPARENT,
            button_cursor: SWFUpload.CURSOR.HAND,

            // The event handler functions are defined in handlers.js
            swfupload_loaded_handler: swfUploadLoaded,
            file_queued_handler: fileQueued,
            file_queue_error_handler: fileQueueError,
            file_dialog_complete_handler: fileDialogComplete,
            upload_start_handler: uploadStart,
            upload_progress_handler: uploadProgress,
            upload_error_handler: uploadError,
            upload_success_handler: uploadSuccess,
            upload_complete_handler: uploadComplete,
            queue_complete_handler: queueComplete,	// Queue plugin event

            // SWFObject settings
            minimum_flash_version: "9.0.28",
            swfupload_pre_load_handler: swfUploadPreLoad,
            swfupload_load_failed_handler: swfUploadLoadFailed
        };

        swfu = new SWFUpload(settings);
    }

Der Parameter flash_url muss auf die swfupload.url verweisen, der Parameter upload_url verweist demnach auf unseren View, den ich später vorstelle. Was zu beachten ist, die URL die zum View führt wird via Slug weitergegeben.

Wie man bereits erkennt hab ich hier custom_settings angegeben und die ganzen Handler-Funktionen ausgelagert. Aber es reicht auch ein minimales Setup wie in der Dokumenation oder Demos beschrieben.

Wichtig sind jedoch die Parameter in post_params! Hier geben wir den csrf_token sowie unseren Slug via POST mit. Das ist wichtig, sonst wird Django böse wenn wir im POST ohne Cross-Site-Request-Forgey – Token ankommen!

Hier meine komplette gallery/add.html:

{% extends "base.html" %}
{% load i18n %}

{% block title %}{% trans "Bilder hinzufügen | fha-django-gallery" %}{% endblock %}

{% block extrahead %}
    <link rel="stylesheet" type="text/css" media="all" href="{{ MEDIA_URL }}swfupload.css" />
    <script type="text/javascript" src="{{ MEDIA_URL }}swfupload.js"></script>
    <script type="text/javascript" src="{{ MEDIA_URL }}swfupload.queue.js"></script>
    <script type="text/javascript" src="{{ MEDIA_URL }}swfupload.swfobject.js"></script>
    <script type="text/javascript" src="{{ MEDIA_URL }swfupload.cookies.js"></script>
    <script type="text/javascript" src="{{ MEDIA_URL }swfupload.fileprogress.js"></script>
    <script type="text/javascript" src="{{ MEDIA_URL }}swfupload.handlers.js"></script>
    <script type="text/javascript">
    var swfu;

    SWFUpload.onload = function () {
        var settings = {
            flash_url: '{{ MEDIA_URL }swfupload.swf',
            upload_url: '{% url gallery_add slug=slug %}',
            file_size_limit: '10 MB',
            file_types: '*.*',
            file_types_description: 'Bilddateien',
            file_upload_limit: 100,
            file_queue_limit: 0,
            custom_settings: {
                progressTarget : 'fsUploadProgress',
                cancelButtonId : 'btnCancel'
            },
            post_params: {
                'csrfmiddlewaretoken': '{{ csrf_token }}',
                'slug': '{{ slug }}'
            },
            debug: false,

            // Button Settings
            button_placeholder_id: "spanButtonPlaceholder",
            button_width: 128,
            button_height: 30,
            button_window_mode: SWFUpload.WINDOW_MODE.TRANSPARENT,
            button_cursor: SWFUpload.CURSOR.HAND,

            // The event handler functions are defined in handlers.js
            swfupload_loaded_handler: swfUploadLoaded,
            file_queued_handler: fileQueued,
            file_queue_error_handler: fileQueueError,
            file_dialog_complete_handler: fileDialogComplete,
            upload_start_handler: uploadStart,
            upload_progress_handler: uploadProgress,
            upload_error_handler: uploadError,
            upload_success_handler: uploadSuccess,
            upload_complete_handler: uploadComplete,
            queue_complete_handler: queueComplete,	// Queue plugin event

            // SWFObject settings
            minimum_flash_version: "9.0.28",
            swfupload_pre_load_handler: swfUploadPreLoad,
            swfupload_load_failed_handler: swfUploadLoadFailed
        };

        swfu = new SWFUpload(settings);
    }
    </script>
{% endblock %}

{% url gallery_add slug=slug as gallery_add %}

{% block breadcrumbs %}
    {% blocktrans %}
        Sie befinden sich hier: <a href="/">fha-django-gallery</a> &raquo;
        <a href="/account/profile/">Account</a> &raquo;
        <a href="{{ gallery_add }}">Bilder hinzufügen</a>
    {% endblocktrans %}
{% endblock %}

{% block content %}
    <h2>{% trans "Bilder zur Galerie hinzufügen" %}</h2>
    <p>{% trans "Um Bilder zur Galerie hinzuzufügen, wählen sie diese bitte aus und klicken anschließend auf Weiter" %}</p>
    <p><a href="{% url gallery_edit slug=slug %}" class="button blue">{% trans "Weiter" %}</a></p>
    <div id="divSWFUploadUI">
        <div class="fieldset flash" id="fsUploadProgress">
            <span class="legend">Warteschlange</span>
        </div>
        <p id="divStatus">0 Dateien hochgeladen</p>
        <p>
            <span id="spanButtonPlaceholder"></span>
            <button id="btnUpload" class="red" type="button">Dateien auswählen</button>
            <button id="btnCancel" type="button" disabled="disabled">Uploads abbrechen</button>
        </p>
    </div>
    <noscript style="background-color: #FFFF66; border-top: solid 4px #FF9966; border-bottom: solid 4px #FF9966; margin: 10px 25px; padding: 10px 15px;">
        {% trans "We're sorry. SWFUpload could not load. You must have JavaScript enabled to enjoy SWFUpload." %}
    </noscript>
    <div id="divLoadingContent" class="content" style="background-color: #FFFF66; border-top: solid 4px #FF9966; border-bottom: solid 4px #FF9966; margin: 10px 25px; padding: 10px 15px; display: none;">
        {% trans "SWFUpload is loading. Please wait a moment..." %}
    </div>
    <div id="divLongLoading" class="content" style="background-color: #FFFF66; border-top: solid 4px #FF9966; border-bottom: solid 4px #FF9966; margin: 10px 25px; padding: 10px 15px; display: none;">
        {% trans "SWFUpload is taking a long time to load or the load has failed.  Please make sure that the Flash Plugin is enabled and that a working version of the Adobe Flash Player is installed." %}
    </div>
    <div id="divAlternateContent" class="content" style="background-color: #FFFF66; border-top: solid 4px #FF9966; border-bottom: solid 4px #FF9966; margin: 10px 25px; padding: 10px 15px; display: none;">
        {% blocktrans %}
            We're sorry. SWFUpload could not load. You may need to install or upgrade Flash Player. Visit the <a href="http://www.adobe.com/shockwave/download/download.cgi?P1_Prod_Version=ShockwaveFlash">Adobe website</a> to get the Flash Player.
        {% endblocktrans %}
    </div>
{% endblock %}

Schreiben der Middleware

Als vorletzten Schritt müssen wir eine Middleware in Django schreiben. Keine Sorge klingt schlimmer wie es eigentlich ist . In der Middleware müssen wir mehrere Dinge beachten: Den Slug extrhahieren, genauso mit dem csrf_token fungieren und ganz wichtig die sessionid aus dem POST rausholen und in request.COOKIES schreiben. Das ganze am Besten unter gallery/middleware.py schreiben.

Hier nun die komplette Middleware:

"""
    This middleware etracts slug, csrf_token and sessionid and gives them django back.
"""

from django.conf import settings
from django.core.urlresolvers import reverse

class SWFUploadMiddleware(object):
    def process_request(self, request):
        if request.POST.has_key('slug'):
            if (request.method == 'POST') and (request.path == reverse('gallery_add', kwargs={'slug': request.POST['slug']})):
                if request.POST.has_key(settings.SESSION_COOKIE_NAME):
                    request.COOKIES[settings.SESSION_COOKIE_NAME] = request.POST[settings.SESSION_COOKIE_NAME]
                if request.POST.has_key('csrftoken'):
                    request.COOKIES['csrftoken'] = request.POST['csrftoken']

Wie gesagt nicht viel Code und relativ einfach ist es auch. Jedoch müssen wir die Middleware noch in die settings.py einfügen damit Django diese auch kennt. Das ganze sollte am Besten an die zweite Stelle der Middlewares eingefügt werden.

MIDDLEWARE_CLASSES = (
    'django.middleware.common.CommonMiddleware',
    'gallery.middleware.SWFUploadMiddleware', #adds our new middleware
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
)

Den Upload verarbeiten

So als letztes brauchen wir noch den View der unsere hochgeladenen Bilder entgegen nimmt und verarbeitet. Selbstverständlich funktioniert das nur wenn man angemeldet ist… wär ja schrecklich wenn jeder User irgendwas hochladen dürfte…

Das ganze ist nicht besonders kompliziert, Django typisch halt. Die Dateien kommen in request.FILES an, über diese müssen wir iterieren und daraus ein Objekt erstellen.

from django.shortcuts import render_to_response
from django.template import RequestContext
from django.http import HttpResponse
from django.contrib.auth.decorators import login_required
from django.middleware.csrf import get_token
from gironimo.gallery.models import Album, Picture

@login_required
def add(request, slug):
    '''
        Adds new images to a given gallery, only authenticated access
    '''
    if request.method == 'POST':
        album = Album.objects.get(slug=slug)
        for field_name in request.FILES:
            image = request.FILES[field_name]

            picture = Picture.objects.create(album=album, image=image)
            picture.save()

        # say ok to SWFUploader
        return HttpResponse("ok", mimetype="text/plain")

    else:
        return render_to_response('gallery/add.html', {
            'slug': slug,
            'csrf_token': get_token(request)
        }, context_instance=RequestContext(request))

Das wars! Wichtig ist nur das wir den csrf_token mitgeben und SWFUpload ein HttpResponse zurück geben, damit er weiß das alles OK war.

Nun sollte das ganze bei euch wunderbar funktionieren, jedoch bleibt noch viel Arbeit das ganze schön aussehen zu lassen denn Flash Sachen nerven beim designen.

Sollte ich irgendwo einen Fehler gemacht haben oder Blödsinn aufgeschrieben haben, sagt mir das wär echt super. Auch für Verbesserungsvorschläge oder andere Ideen wäre ich dankbar (natürlich ist ein Danke auch super )

Artikelserie Web-Sicherheit:

• SQL-Injection
  SQL-Injection (dt. SQL-Einschleusung) bezeichnet das Ausnutzen einer Sicherheitslücke in Zusammenhang mit SQL-Datenbanken, die durch mangelnde Maskierung oder Überprüfung von Metazeichen in Benutzereingaben entsteht. Der Angreifer versucht dabei, über die Anwendung, die den Zugriff auf die Datenbank bereitstellt, eigene Datenbankbefehle einzuschleusen. Dieser Artikel zeigt die Funktionsweise einer SQL-Injection sowie einfach zu implementierende Gegenmaßnahmen. [Artikel lesen]
• Cross-Site-Scripting (XSS)
  Mit Cross-Site Scripting (XSS) wird das Ausnutzen einer Computersicherheitslücke in Webanwendungen bezeichnet, indem ein Angreifer Webseiten mit clientseitigen Skripten infiziert, die von anderen Nutzern aufgerufen werden. Der Artikel geht auf Folgen und Funktionsweise dieser Methodik ein und veranschaulicht Schutzmaßnahmen für Webseitenbetreiber. [Artikel lesen]
• Header-Injection
  Header-Injection ist eine Klasse von Sicherheitslücken in Webanwendungen, welche auftreten, wenn die Header eines Protokolls dynamisch unter Hinzunahme von unzureichend geprüften Benutzereingaben generiert werden. Hier beschreibe ich anhand eines Beispiels die Funktionsweise und entsprechende Maßnahmen gegen die Ausnutzung solch eines Angriffs. [Artikel lesen]
• HTTP-Response Splitting
  Einfügen präparierter Inhalte in den HTTP-Header um die Seitendarstellung und Seiteninhalte zu manipulieren. Dieser Artikel geht auf die möglichen Folgen, die Funktionsweise und Gegenmaßnahmen ein. [Artikel lesen]

Buchrezensionen:

• xt:Commerce Veyton 4 [Rezension lesen]
  
• Web X.0 Erfolgreiches Webdesign und professionelle Webkonzepte [Rezension lesen]
• jQuery: Das Praxishandbuch [Rezension lesen]
• Fortgeschrittene CSS-Techniken – inkl. Debugging und Performace-Optimierung [Rezension lesen]
• Sichere Webanwendungen – das Praxishandbuch für Webentwickler [Rezension lesen]
• Magento – Installation, Anwendung, Erweiterung [Rezension lesen]
• Recht für Grafiker und Webdesigner (Ausgabe 2011) [Rezension lesen]

Weitere Artikel:

• Tooltips mit JavaScript erzeugen – jQuery
  In diesem kleinen Artikel wollen wir mit Hilfe von jQuery eine Tooltip auf Albert Einsteins Zunge legen. [Artikel lesen]
• UD Media Webspace & Webhosting
  Kleine Vorstellung des deutschen Internetproviders. [Artikel lesen]

weitere News, Artikel und Neuigkeiten findet ihr auf meiner Profilseite bei webmasterpro.de. Viel Spaß beim Lesen.

Update 14.04.2011:
Adobe hat mittlerweile die Creative Suite CS5.5 angekündigt, das am 3. Mai erscheinen soll. Unter anderem sollen viele Updates für HTML5 enthalten sein. Die Adobe Creative Suite 5.5 Students ist bis zu 80% billiger zu haben.

Mithilfe von CSS3 kann beispielsweise ein Text einen Schatten bekommen oder eine ganze Box. Verläufe im Hintergrund sind auch möglich ohne Bilder zu verwenden. Eigene Schriftarten können auf die Webseite eingebettet, usw usf. Für jeden Webdesigner/Webentwickler ist es ein Muss, sich mit HTML5 und CSS3 zu beschäftigen. Doch wo liegt der Vorteil? Ganz klar, die Performance ist deutlich besser, außerdem müssen sich Webentwickler ohne große Photoshop Kenntnisse nicht mehr abmühen, bis sie endlich an die richtige Arbeit können.
Im folgenden möchte ich euch zeigen, was mit mit der CSS3 Eigenschaft box-shadow möglich ist.

Normale Box mit einfachen box-shadow

Jedoch ist ein viel “schönerer” Effekt ebenfalls möglich:

Box mit coolem box-shadow

Das alles ist möglich mit reinem CSS und einem DIV! Also ran an die Arbeit!

1. Schritt: Grundgerüst erstellen

In eurem HTML-Dokument reicht es wenn ihr folgendes erstellt:

<div id="box">
    Nice CSS3 Box Shadow
</div>

Mit einem einzigen DIV können wir viele tolle Sachen in CSS machen. Wir werden nun einen Verlauf, text-shadow, box-shadow sowie die etwas experimentelle CSS Eigenschaft transform: matrix verwenden.

2. Schritt: CSS Grundlayout

Achtung: Es sind hier nur Webkit Prefixe eingearbeitet. Mozilla (-moz-) und Opera (-o-) fehlen hier, können aber selbstverständlich ebenfalls verwendet werden.

* {
    margin: 0;
    padding: 0;
}
body {
    background-color: #ddd;
    font-family: Trebuchet MS, Arial, Verdana, Helvetica, sans-serif;
    font-size: 100.01%;
}
#box {
    width: 300px;
    height: 220px;
    margin: 50px auto;
    position: relative;
    background: -webkit-gradient(linear, 0 0, 0 100%, from(#fefbb0), to(#fff955));
    -webkit-box-shadow: 0px 0px 3px rgba(0, 0, 0, 0.4);
    -webkit-border-radius: 10px;
    font-size: 2em;
    color: #fff;
    text-shadow: 1px 1px 2px rgba(1, 1, 1, 0.8);
    text-align: center;
    padding-top: 80px;
}

Also was machen wir? Wir geben unserer Box eine Höhe, Breite sowie position: relative, das wir später noch brauchen, sowie einen Hintergrundverlauf mit gradient. Die Box bekommt auch gleich einen einfachen Schatten. Zudem setzen wir Angaben zur Schrift.

3. Schritt: Pseduo Klassen :before und :after machen tolle Effekte

Mit den Pseudo Klassen :before und :after werden wir nun den Effekt zaubern. Beide müssen position: absolute bekommen, damit wir sie genau auf die Box ausrichten können (merke position: relative von #box). Zudem setzen wir beide Pseudo Klassen mit einem z-index hinter die Box. Dort wo ein Schatten auch sein sollte…

#box:before,
#box:after {
    position: absolute;
    content:'';
    background-color: transparent;
    bottom: 12px;
    width: 70%;
    height: 60px;
    z-index: -1;
    -webkit-border-radius: 10px;
}
#box:before {
    -webkit-box-shadow: -14px 12px 10px rgba(2, 2, 2, 0.6);
    -webkit-transform: matrix(1, -0.05, -0.2, 1, 0, 0);
    left: 15px;
}
#box:after {
    -webkit-box-shadow: 14px 12px 10px rgba(2, 2, 2, 0.6);
    -webkit-transform: matrix(1, 0.05, 0.2, 1, 0, 0);
    right: 15px;
}

Hier kommt CSS3 richtig zum Einsatz. Mithilfe von rgba Angaben und box-shadow erzeugen wir eine neue Box mit Schatten (jeweils für :before und :after). Die transformieren wir. Mit einer Matrix Angabe können wir die Box unseren Wünschen anpassen. Wer dazu mehr Informationen möchte, sollte sich die Spezifikation des W3 ansehen.

Versucht mal den z-index wegzulassen, bzw höher zu stellen, und ihr werdet sehen, welche Boxen, die als Schatten herhalten, wirklich erzeugt werden. Viel Spaß dabei.

Wer eine kreative und innovative CSS3 und HTML5 Homepage erstellen möchte, jedoch nicht selbst Hand anlegen will, sollte sich mal bei der Webagentur Team23 umsehen.

Alle Statistiken wurden mithilfe von Google Analytics erstellt. Das heißt zum einen auch, das eventuell nicht alle Besucher erfasst sind, da es nun ja auch Plugins gibt um Google Analytics auszuschalten und Personen die ohne JavaScript surfen, werden ebenfalls nicht erfasst.

Das wichtigste zuerst, die Gesamtstatistiken:

Statistiken sind toll, mir zeigt es eindeutig das meine Homepage mehr Besucher anzieht und diese auch nicht sofort wieder abhauen, sondern auch lesen was hier alles gibt.

Die TOP 5 der verwendeten Browser:

Hier lässt sich auch allgemein einiges ableiten. Google Chrome feiert einen Siegeszug durchs Internet. Mozilla Firefox ist in Deutschland weitestgehend der am meisten genutzte Browser während der Internet Explorer immer mehr Marktanteil verliert. Opera und Safari teilen sich dann die unteren Plätze.

Die TOP 5 der verwendeten Betriebssysteme:

Während der Marktanteil bei Macs und Linux rapide sank (wieso nur???) sieht man einen deutlichen Zuwachs an Windows User, aber auch Mobiltelefone bzw. andere Apple Produkte sind am wachsen.

Am wichtigsten ist jedoch welche Artikel am meisten gelesen von den Besuchern gelesen wurden. Daraus lässt sich auch ableiten welche Zielgruppe eher auf die Webseite kommt. Jedoch verfälschen andere interessante Themen, zu denen nur ein Artikel vorhanden ist, natürlich diese Ableitung. Also zu guter Letzt, die wichtigste Statistik, die am meisten gelesenen Artikel:

Dann bleibt mir nur Danke zu sagen, für die zahlreichen Besucher, die ich dieses Jahr hatte und verspreche gleichzeitig eine Überraschung für 2011, denn die Seite wird gerade generalüberholt. Auch werde ich versuchen oft genug, neue interessante Artikel zu schreiben.

Einen guten Rutsch, und ja nicht ausrutschen!