QpLuS-IM Projekt „Komm’Se digital lernen“ erfolgreich abgeschlossen

Nach spannenden drei Jahren, die einige Überraschungen bereit hielten, haben wir unser Projekt QpLuS-IM nun beendet.

Einzelheiten zu Ergebnissen und Erkenntnissen findet Ihr im Abschlussbericht des Projekts auf unserem QpLuS-IM Blog:

Erfolgreicher Projektabschluss

Auch eine News auf der HsH-Website fasst es gut zusammen:

Herzlichen Dank an alle Beteiligten und Unterstützer:innen!

Text und Data Mining in Bibliotheken?

Autorin: Lene-Christine Brammer


Image by mcmurryjulie
Image by mcmurryjulie

Bibliotheken haben den Auftrag, Medien und Informationen für Nutzerinnen und Nutzer aufzuarbeiten und bereitzustellen. Doch jedes Jahr werden mehrere Millionen Publikationen veröffentlicht. Die DNB allein verzeichnete den Zugang 2.352.693 neuer Einheiten im Jahre 2020[1]. Wer soll da den Überblick behalten? Text und Data Mining kann hier Abhilfe schaffen. 

Was ist Text und Data Mining?

Text Mining, Data Mining, Text Data Mining, Textual Data Mining, Text Knowledge Engineering, Web Mining, Web Content Mining, Web Structure Mining, Web Usage Mining, Content Mining, Literature Mining und sogar Bibliomining[2] – viele Begriffe, die alle das selbe Konzept – teilweise mit unterschiedlichen Schwerpunkten – bezeichnen, welches im Folgenden Text und Data Mining, kurz TDM, genannt werden soll. Grob gesagt ist damit die algorithmusbasierte automatische Analyse digitaler Daten jeglicher Form gemeint.

TDM beinhaltet dabei explizit sowohl die Verarbeitung natürlichsprachiger Texte, sogenannter unstrukturierter Daten, als auch beispielsweise Tabellen und anderer strukturierter Daten, welche unterschiedliche Anwendungsfälle und Herausforderungen mit sich bringen. Dabei gibt es zwei große Aspekte: das Auffinden bereits bekannter Informationen und die Schaffung neuen Wissens durch die Verknüpfung oder Neuinterpretation von Bekanntem.[3]

Ganz allgemein lassen sich Verfahren des TDM in drei große Bereiche aufteilen:

  • Musterextraktion (Programm analysiert, welche Daten oft gemeinsam auftreten)
  • Segmentierung (Programm gruppiert ähnliche Daten zusammen)
  • Klassifikation (Programm teilt Daten vorher bestimmten Klassen zu)

Es lässt sich natürlich noch feiner unterteilen in Regressionsanalysen, Abhängigkeits- oder Abweichungsanalyse, Beschreibung, Zusammenfassung, Prognose, Assoziation etc., was die große Bandbreite an Nutzungsmöglichkeiten des TDM aufzeigt[4], für uns aber gerade zu weit geht, da wir nur den Bereich der Bibliotheken betrachten wollen.

Anwendungsmöglichkeiten für Bibliotheken

Empfehlungssysteme

Eine Möglichkeit der Kataloganreicherung ist die Implementierung eines Empfehlungsdienstes. Dieser analysiert Recherche- und/oder Ausleihdaten, um Nutzenden während ihrer Recherche weitere Medien vorzuschlagen, die relevant für sie sein könnten[5]. Ein solcher Dienst ist BibTip, welcher an der Universität Karlsruhe entwickelt wurde und mittlerweile von vielen wissenschaftlichen und öffentlichen Bibliotheken in Deutschland verwendet wird. 

Maschinelle Indexierung

Die inhaltliche Erschließung bietet einen großen Mehrwert bei der Recherche, ist jedoch ein zeit- und personalaufwendiger Aspekt der bibliothekarischen Arbeit. Schon 2009 begann die Deutsche Nationalbibliothek, diese Arbeit mit maschineller Unterstützung durchzuführen. Dabei wurden die in der GND hinterlegten Schlagwörter als Grundlage für die automatische Verschlagwortung mithilfe des Averbis-Programms verwendet.[6] 

Herausforderungen 

Urheberrecht

TDM war viele Jahre eine rechtliche Grauzone. Unklarheiten bezogen sich unter anderem darauf, ob maschinelle Verarbeitung durch die bestehenden Lizenzverträge abgedeckt war, ob temporäre für die Auswertung erstellte Kopien unerlaubte Vervielfältigung bedeuteten, inwieweit die Ergebnisse Dritten zugänglich gemacht werden durften und vieles mehr.[7] Die Urheberrechtsnovelle 2018 sorgte für mehr Klarheit, indem durch § 60d UrhG explizit die Nutzung von TDM für die wissenschaftliche Forschung erlaubt wurde.

Datenschutz

Datenschutz ist vor allem bei der Verarbeitung personenbezogener Daten wie der Analyse von Ausleih- oder Recherchevorgängen relevant. Im Sinne der Datensparsamkeit dürfen nur so viele Daten erhoben werden, wie erforderlich sind und diese auch nur so lange wie nötig gespeichert werden. Aus Datenschutzgründen werden die Daten deshalb anonymisiert gespeichert und verarbeitet. Dies schränkt beispielsweise die Empfehlungsdienste ein, da so nur die aufgerufenen oder ausgeliehenen Medien während eines einzelnen Vorgangs analysiert werden, diese jedoch nicht mit früheren Vorgängen der selben Person verknüpft werden können.

Formatvielfalt

TDM kann nur funktionieren, wenn die auszuwertenden Daten in geeigneter Form vorliegen. Dabei kann es verschiedene Hürden geben, sowohl rechtlicher Natur, wenn Daten im Besitz von Personen oder Institutionen sind, sowie technischer Natur, wenn Daten nicht in maschinenlesbarer Form vorliegen, oder zu viele verschiedene (inkompatible) Dateiformate genutzt werden.[8]

Ausblick

Schon heute profitieren Bibliotheken von TDM-Anwendungen, besonders Empfehlungsdienste sind verbreitet. Maschinelle Indexierung wird zumindest vereinzelt eingesetzt, bleibt in der Qualität aber noch weit hinter der intellektuellen Erschließung durch Menschen zurück.[9] Aufgrund des technischen Fortschritts und dem immer zuverlässiger werdenden natural language processing darf man hier jedoch hoffnungsvoll in die Zukunft blicken.

Doch Bibliotheken sind nicht nur Anwenderinnen, sondern können und sollten ebenfalls Sorge dafür tragen, dass ihre eigenen Bestände für TDM nutzbar sind. Dies wird erleichtert durch § 60d UrhG, aber sollte auch bei der Aushandlung von Lizenzverträgen, bei der Auswahl der anzubietenden Formate von elektronischen Medien wie auch bei der Retrodigitalisierung beachtet werden.

Quellen

[1] Deutsche Nationalbibliothek (2021): Jahresbericht 2020. S.45. Online unter urn:nbn:de:101-2021051859

[2] Mehler, Alexander; Wolff, Christian (2005): Einleitung: Perspektiven und Positionen des Text Mining. In: LDV-Forum, Jg. 20, Nr. 1, S. 1–18. Online unter urn:nbn:de:0070-bipr-1688

[3] Saffer, Jeffrey; Burnett, Vicki. (2014). Introduction to Biomedical Literature Text Mining: Context and Objectives. In Kumar, Vinod; & Tipney, Hannah (Hg.): Biomedical Literature Mining. New York: HumanaPress, Springer. S. 1–7. Online unter doi.org/10.1007/978-1-4939-0709-0_1

[4] Drees, Bastian (2016): Text und Data Mining: Herausforderungen und Möglichkeiten für Bibliotheken. In: Perspektive Bibliothek, Jg. 5, Nr. 1, S. 49-73. Online unter doi.org/10.11588/pb.2016.1.33691

[5] Mönnich, Michael; Spiering, Marcus (2008): Erschließung. Einsatz von BibTip als Recommendersystem im Bibliothekskatalog. In: Bibliotheksdienst, Jg. 42, Nr. 1, 54–59. Online unter doi.org/10.1515/bd.2008.42.1.54

[6] Uhlmann, Sandro (2013): Automatische Beschlagwortung von deutschsprachigen Netzpublikationen mit dem Vokabular der Gemeinsamen Normdatei (GND). In: Dialog mit Bibliotheken, Jg. 25, Nr. 2, S.26-36. Online unter urn:nbn:de:101-20161103148

[7] Okerson, Ann (2013): Text & Data Mining – A Librarian Overview [Konferenzbeitrag]. Herausgegeben von IFLA. Online unter http://library.ifla.org/252/1/165-okerson-en.pdf (Abruf am 29.01.2022)

[8] Brettschneider, Peter (2021): Text und Data-Mining – juristische Fallstricke und bibliotheksarische Handlungsfelder. In: Bibliotheksdienst, Jg. 55, Nr. 2, S. 104-126. Online unter doi.org/10.1515/bd-2021-0020

[9] Wiesenmüller, Heidrun (2018): Maschinelle Indexierung am Beispiel der DNB. Analyse und Entwicklungmöglichkeiten. In: O-Bib, Jg. 5, Nr. 4, S. 141-153. Online unter doi.org/10.5282/o-bib/2018H4S141-153


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Content Management (Wintersemester 2021/22, Dr. Stefanie Elbeshausen) entstanden.

Die besten Beiträge stellen wir Euch hier in den nächsten Wochen nach und nach vor.

Was hat User Experience mit SEO zu tun?

Kombination von User Experience und SEO

Autor*in: Lea Weiß


Beschäftigt man sich mit der Erstellung von Webseiten, begegnen einem früher oder später auch die Begriffe User Experience (UX) und Search Engine Optimization (SEO). Wenn Du diese Begriffe noch für komplettes Neuland hältst, bist Du hier genau richtig. Beleuchten wollen wir dabei die Kombination von User Experience und SEO. Nach einer kurzen Einführung in das Thema werden wir anhand einiger entscheidender Hintergründe nachvollziehen, weshalb User Experience und SEO immer stärker im Zusammenhang betrachtet werden.

Aufgrund der beobachteten Annäherung von SEO und User Experience gewinnt auch Search Experience Optimization (SXO) an Bedeutung. Denn diese Bezeichnung vereint beide Disziplinen. Dabei eröffnet sich ein spannender Themenkomplex, der hoffentlich auch einige Mitstudierende des Informationsmanagements motiviert, sich (noch) näher mit User Experience und SEO zu beschäftigen.

Anschließend an diesen Beitrag kannst Du in einem kleinen Quiz Dein neues Wissen über SEO und UX testen!

Inhaltsverzeichnis

  1. Was sind User Experience und SEO?
    1. User Experience (UX)
    2. SEO
  2. Entwicklung von SEO
    1. SEO – Black Hat-Methoden
    2. Reaktionen von Google auf unerwünschte SEO
  3. Kombination von UX und SEO
    1. Auswirkungen der Google-Updates – Was hat UX mit SEO zu tun?
    2. UX und Nutzersignale
    3. Kombination von User Experience und SEO im UX Design
  4. Fazit
  5. Quiz
  6. Mehr zu UX und SEO
  7. Quellen

Was sind User Experience und SEO?

User Experience und SEO, was ist das überhaupt? Zunächst schauen wir uns die Definition beider Begriffe an. Anschließend wollen wir mit diesem Hintergrundwissen in das zentrale Thema, der Kombination von User Experience und SEO, einsteigen.

User Experience (UX)

User Experience einerseits, abgekürzt auch einfach UX, betrachtet die Nutzererfahrung auf allen Ebenen. Das bedeutet, alle Empfindungen und Reaktionen vor, während und nach der Nutzung eines beliebigen Produkts beeinflussen die User Experience.[1] In Verbindung mit SEO stehen in diesem Beitrag Webseiten und deren Gestaltung im Mittelpunkt. Das Ziel von UX-Expertinnen und UX-Experten ist, die Produktnutzung so angenehm und unterhaltsam wie möglich zu gestalten.

Ein weiterer, häufig gebrauchter Begriff im Zusammenhang mit Web Design ist Usability. Um User Experience zu verstehen ist es hilfreich, Usability erst einmal getrennt davon zu betrachten. Gemeint ist damit die Gebrauchstauglichkeit und somit Nutzerfreundlichkeit einer Webseite aus technischer Sicht. Demnach wird untersucht, ob alle Elemente ohne Komplikationen funktionieren und zu finden sind. Häufig fällt allerdings nur eine negative Usability auf, wie einigen Beiträgen zu diesem Thema zu entnehmen ist. Gute Gebrauchstauglichkeit hingegen bleibt eher unauffällig. Folglich sind keine Beschwerden bezüglich der Nutzbarkeit schon beinahe positiv zu bewerten.[2]

Im Gegensatz dazu ist für die Nutzererfahrung eine ganzheitliche Betrachtung von Bedeutung. Technische Aspekte wie die Gebrauchstauglichkeit spielen zwar auch eine Rolle, jedoch niemals die alleinige. Werden demzufolge ästhetische Gesichtspunkte und Emotionen im Einklang mit der technischen Nutzbarkeit gesehen, geht es um User Experience.[1]

SEO

SEO andererseits steht für Search Engine Optimization, auf Deutsch Suchmaschinenoptimierung. Dabei beschäftigt man sich mit der Verbesserung der Auffindbarkeit von Webseiten in Suchmaschinen. Darüber hinaus steht diese Abkürzung gelegentlich auch als Synonym für die Person eines Suchmaschinenoptimierers (SEO Manager).

Vereinfacht ausgedrückt beschreibt der Begriff User Experience die Menschensicht und SEO die Maschinensicht auf Web-Inhalte. Doch welche Gemeinsamkeiten gibt es zwischen diesen beiden Gestaltungseinflüssen?

Entwicklung von SEO

Das Ziel dieses Beitrags ist, wie zuvor erwähnt, Berührungspunkte von SEO und UX herauszustellen. Dafür schauen wir uns zunächst die Entwicklungsgeschichte von SEO an. Als Beispiel wollen wir uns im Folgenden auf Google beziehen. Wie unten abgebildeter Karte zu entnehmen ist, ist Google unangefochtener weltweiter Marktführer. Eine Ausnahme stellt China dar, mit seiner eigenen Suchmaschine Baidu.

Kombination von User Experience und SEO
Suchmaschinen Marktanteil weltweit, Stand: Januar 2021;
Quelle: StatCounter Global Stats – Search Engine Market Share; Lizenz: CC BY-SA 3.0; Originaldatei .png geändert zu .jpg

Der weltweite Marktanteil von Google betrug im Januar 2021 91.86 % (s. o.). In Deutschland erreichte Google einen Anteil von 91.56 %. Als zweitgrößte Suchmaschine wird in Deutschland Bing genutzt (5.23 %). Weitere Suchmaschinen mit geringeren Anteilen sind Ecosia, DuckDuckGo oder Yahoo.[3]

SEO – Black Hat-Methoden

Die Reihenfolge (Ranking) in den Suchmaschinen-Trefferseiten (SERPs) wird anfangs in erster Linie von technischen und inhaltlichen Merkmalen beeinflusst. Markus Hübener hat diese beispielsweise in einem “9-Punkte-Optimierungsplan” im Jahr 2009 beschrieben.[4] Auffälligerweise sind darin aber noch keine eindeutigen Kriterien für User Experience mit einbezogen.

Ursprünglich wurden also die Technik, der Inhalt (Content) und auch Verlinkungen als Basiskriterien für das Ranking herangezogen. Aus technischer Sicht sind dabei etwa die Ladegeschwindigkeit und Indexierbarkeit durch Webcrawler zu beachten. Als inhaltliche Aspekte sind dafür vor allem die Semantik und Suchwörter (Keywords) heranzuziehen. Bei den Links sind dann Rückverweise auf die eigene Webseite (Backlinks) von besonderem Interesse.[5] Die Kenntnis darüber führt jedoch auch zu bewussten Manipulationen von Webseiten, um ein hohes Ranking in der Ergebnisliste zu erzielen. Unerlaubte Optimierungsarten dabei werden auch Black Hat genannt. Im Gegensatz dazu werden erlaubte Taktiken als White Hat bezeichnet.

Folgende Verfahren können wir zu den Black Hat-Methoden zählen:

Reaktionen von Google auf unerwünschte SEO

Um betrügerisches Verhalten aufzudecken entwickelt Google seine Algorithmen stets weiter. Infolgedessen werden überoptimierte Webseiten durch Verbannung von den hohen Rankingplätzen abgestraft. Zu den dazu gehörigen Meilensteinen zählt das sogenannte “Panda-Update” im Jahr 2011. In Bezug auf die Content Farmen war es anfangs auch als “Farmer Update” bekannt. Darauf folgte ein besonders wichtiges Update aus dem Jahr 2015, genannt “RankBrain”. Seitdem beeinflusst es vor allem die Sprachsuche unter erstmaligem Einsatz von Machine Learning. Nicht zuletzt verbesserte Google mit dem “Fred-Update” im Jahr 2017 den Bewertungsalgorithmus für die Inhaltsqualität von Webseiten erneut.[6], [7]

Was ist Flask?

Was ist Flask?

Autor: Esben Christian Pedersen


Inhalt

Was ist Flask überhaupt?

Flask ist ein WSGI Micro-Framework für Webapplikationen. Ursprünglich wurde Flask als Aprilscherz von Armin Ronacher im Jahr 2010 entwickelt. Auf Grund steigender Beliebtheit unter den Usern, gründete Armin Ronacher die „The Pallets Project“-Sammlung von Open Source Code Bibliotheken. Diese Sammlung dient nun als Organisation hinter Flask und weiteren Bibliotheken wie Werkzeug und Jinja, um die Flask aufgebaut ist. Dabei stützt sich Flask nur auf die nötigsten Komponenten die für die Webentwicklung benötigt werden ( routing, request handling, session). Alle anderen Komponenten müssen dementsprechende entweder selbst entwickelt oder über zusätzliche Pakete hinzugefügt werden.[1]

Was Flask so außergewöhnlich macht ist der simple Einstieg und die Effizienz im Zusammenspiel mit anderen Python Bibliotheken. Was dem Entwickler erlaubt Web-Applikationen mit Flask im größeren Stil zu entwickeln und auszubauen, ohne dem Entwickler etwas aufzuzwingen. Da die „The Pallets Project“-Sammlung sich einer großen Unterstützer Community erfreut, gibt es viele Erweiterungsmöglichkeiten welche die Funktionalität erhöhen und Flask äußerst flexibel werden lässt.[2]

Wie das Micro-Framwork Flask funktioniert soll in den folgenden Teilen dieses Beitrags deutlich werden. Sei es die simple installation, oder die einfach Handhabung.


Installation

Wie einfach es ist mit Flask eine Web-Applikation mit Flask zu erstellen soll in den folgenden Abschnitten deutlich werden.

Des Weiteren bietet es sich an beim Entwickeln einer Flask Web-Applikation eine virtuelle Entwicklungsumgebung wie Pythons hauseigene virtualenv zu verwenden um Projektabhängigkeiten und Bibliotheken für jedes Projekt entsprechend zu verwalten. Außerdem ermöglicht die virtualenv eine schnelle und einfach Portierung bzw. ein schnelles unkompliziertes Deployment einer Applikation.

Wie Pythons virtuelle Entwicklungsumgebung funktioniert ist hier näher beschrieben „virtualenv“.

Um Flask zu installieren kann man einfach “pip” benutzen. Dies ist der Package Installer für Python:

$ pip install Flask

So einfach lässt sich Flask installieren mit seinen benötigten Paketen installieren.[3]

Hello World!

Wie einfach das erstellen einer Web Applikation mit Python und Flask ist soll an einem simplen “Hello World” Beispiel verdeutlicht werden. Dazu wird die Datei “app.py” angelegt. Diese lässt sich einfach mit einem Texteditor öffnen und bearbeiten (z.B. PyCharm oder VS Code).

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return "Hello World!"

if __name__ == '__main___':
    app.run()

Zur Erklärung: In Zeile 1 importieren wir Flask und in initieren in Zeile 3 eine neue Instanz der Flask-Klasse und weisen sie der Variable “app” zu. In Zeile 5 wird ein “Decorator” benutzt um die Route/View “/” der View-Funktion “index()” zuzuweisen. Also einfach gesagt: Wird die Seite “/” des Servers im Browser angefragt, so führt dieser die View-Funktion aus die den Content “Hello World!” bereitstellt.[4]

Der letzt Abschnitt des Codes startet den Server sobald die Datei für den Interpreter aufgerufen wird. Wenn alles richtig installiert ist sollte nun folgender output zu sehen sein:

(webapp) $ py app.py
 * Serving Flask app "app" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Die im Code erstellte Seite “/” mit der “index()”-Funktion lässt sich einfach über den Webbrowser öffnen. Dazu lediglich in der Adresszeile des Browser auf “http://localhost:5000/” oder “http://127.0.0.1:5000/” aufrufen. Die aufgerufene Seite sollte nun “Hello World!” in der linken oberen Ecke zeigen.

Routing and Views

Routing bezeichnet das auflösen und händeln von URLs. Dabei soll beim aufrufen einer URL der korrekte Inhalt im Browser dargestellt werden. Bei Flask wird dies mit dem Route- “Decorator” eine Funktion an eine URL gebunden um ihren Content nach dem Aufrufen der URL bereitzustellen. Das folgende Bild soll den Ablauf der URL Auflösung und dem damit verbunden bereitstellen von Content verdeutlichen.[5]

Im vorangegangenen Hello World Beispiel wird dies in Zeile 5 und 6 gemacht. Nach dem aufrufen der URL “http://localhost:5000/” sollte in der Konsole/der Shell folgendes zu sehen sein:

(webapp) $ py app.py
 * Serving Flask app "app" (lazy loading)
 * Environment: production
   WARNING: This is a development server. Do not use it in a production deployment.
   Use a production WSGI server instead.
 * Debug mode: off
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
127.0.0.1 - - [29/Jan/2021 11:56:33] "GET / HTTP/1.1" 200 –

Es ist zu sehen das der Browser eine Anfrage für die „/“-Route an den Server stellt. Dieser verarbeitet die Anfrage entsprechend der mit der Route verbundenen View-Funktion “index()”. Im Anschluss sendet der Server http-status: 200 (OK) und rendert „Hello World!“.

In der Konsole stehen sämtliche Anfragen und http-status codes die vom Flask-Server verarbeitet werden.

Routen und http-Methoden:

Der „Decorator“ kann ein weiteres Argument annehmen. Dieses Argument ist eine Liste mit den für den „Decorator“ erlaubten http-Methoden.

from flask import Flask

app = Flask(__name__)

@app.route(„/users/“, methods=['GET', 'POST'])
def users():
    # Routr Logic #

Somit lassen sich Routen in der Nutzung bestimmter http-Methoden einschränken. Ist jedoch keine Liste angegeben so ist die “GET”-Methode als Standard festgelegt.

Mithilfe der “Decorator” lassen sich auch dynamische und variable Regeln für Routen festlegen, da statische Routen eine Website stark einschränken können. So lässt sich im folgenden Beispiel eine Profilseite für registrierte User anlegen oder gepostete Artikel/Beiträge bekommen eine eigene URL basierend auf dem Datum an dem sie Online gestellt worden und ihrem Titel.

Dabei geben die „<>“ an ob es sich um eine Variable handelt. So lassen sich Routen dynamisch generieren. Zusätzlich lässt sich der Variablen-Typ angeben der verarbeitet werden soll „<datatype:variablename>“. Folgende Variablentypen sind für Routen vorgesehen und möglich:

  • string: Akzeptiert Text ohne „/“.
  • int: Akzeptiert ganze Zahlen (integers).
  • float: akzeptiert numerische Werte die einen Dezimalpunkt enthalten.
  • path: Akzeptiert Text mit „/“ (Pfadangaben)

Dynamische Routen können dementsprechend im Gegensatz zu statischen Routen Parameter entgegennehmen und verarbeiten. Somit ließe sich auch eine API mit Flask umsetzen um Daten für User zugänglicher und nutzbarer zu machen oder einen erhöhten Automatisierungsgrad für Datenabfragen zu ermöglichen. Um dies deutlich zu machen dienen die folgenden Beispiele:[6]

from flask import Flask, escape

app = Flask(__name__)

@app.route(„/users/<username>“)
def profile(username):
    return f'<h1>Welcome { escape(username) }</h1>'
Return “randomuser” nach Browseranfrage
from flask import Flask, escape

app = Flask(__name__)

@app.route(„/article/<int:year>/<int:month>/<title>“)
def article(year, month, title):
    month_dict = {
        "1": "January",
        "2": "February",
        "3": "March",
        "4": "April",
        "5": "May",
        "6": "June",
        "7": "July",
        "8": "August",
        "9": "September",
        "10": "October",
        "11": "November",
        "12": "December"
        }
    return f'<h1>"{ escape(title) }" from { escape(month_dict[str(month)]) } { escape(year) }</h1>'
Return Date and Title nach Browseranfrage

So einfach diese Beispiele sind, so geben sie doch einen deutlichen Ausblick auf die Möglichkeiten, welche sich mit Flask bieten. Welche Unternehmen Flask in ihrer Entwicklung benutzen kann hier eingesehen werden.

Die Template Engine

Wie werden jetzt aus statischen HTML-Dateien dynamische Websiten mit Flask? Ganz einfach, mit Hilfe der eingebauten Template Engine Jinja. Jinja ist eine vielseitige und einfache Templete Engine mit der sich unter anderem auch dynamische HTML-Inhalte erstellen lassen. Sie basiert dabei auf der “Django” Template Engine bietet jedoch viel mehr Möglichkeiten wie volle “unicode” Unterstützung und “automatic escaping” für mehr Sicherheit in Webanwendungen. Zusätzlich lassen sich die gängisten verwendeten Codeblöcke der html-templates immer wieder verwenden und vielseitig einsetzen. Dabei verwendet die Template Engine Variablen, Ablauflogiken und Anweisungen um im Template verwendete Ausdrücke mit Inhalt zu füllen.[7]

Funktionsweise Template Engine Jinja

Um das ganze noch mehr zu veranschaulichen dient der folgende Beispiel Code mit der angegeben Projektstruktur:

|-- app.py
|-- static
|   `-- css
|       `-- main.css
-- templates
    |-- about.html
    |-- index.html
    |-- layout.html
    `-- page1.html
<!DOCTYPE html>
<html lang="en">

  <head>
    <!-- meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
    <!-- Title: -->
    <title>Flask App</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='css/main.css') }}">
  </head>
    <!-- Start of body -->
  <body>
    <header>
      <h1>Flask Web App</h1>
    </header>
    <div class="navbar">
      <strong><ul class="navmenu">
        <li><a href="{{ url_for('home') }}">Home</a></li>
        <li><a href="{{ url_for('page1') }}">Page 1</a></li>
        <li><a href="{{ url_for('about') }}">About</a></li>
      </ul></strong>
    </div>
    <content>
      <div class="container">
        <!-- At this place the child templates get rendered by Flask -->
        {% block content %}
        {% endblock %}
      </div>
    </content>
  </body>
</html>
{% extends "layout.html" %}

{% block content %}
<br>
<br>
<h1> Welcome to the Flask Web App</h1>
<br>
<br>
{% endblock %}
{% extends "layout.html" %}

{% block content %}
<br>
<br>
<h1> Page 1 example</h1>
<br>
<br>
{% endblock %}
{% extends "layout.html" %}

{% block content %}
<br>
<h2> About this Web App:</h2>
<br>
<h3> This App was build using Flask</h3>
{% endblock %}
/* main.css file containing the styling information for the flask webapp */

body {
    margin: 10;
    padding: 5;
    font-family: "Helvetica Neue", Arial, Helvetica, sans-serif;
    color: #444;
}

/* Header */

header {
    background-color: lightblue;
    height: 40px;
    width: 100%;
    opacity: .9;
    margin-bottom: 10px;
}

header h1 {
    margin: 0;
    font-size: 1.7em;
    color: black;
    text-transform: uppercase;
    float: left;
}

/* Body content */

.container {
    width: 100%;
    margin: 15;
}

/* navbar */

.navbar {
    margin: 5px;
    padding: 5px;
    border: 5px;

}

.navmenu {
    float: left;
    margin-top: 8px;
    margin-bottom: 8px;
    padding: 5px;
}

.navmenu li {
    display: inline;
}



.navmenu li a {
    color:slategray;
    text-decoration: none;
}
from flask import Flask, escape, render_template

app = Flask(__name__)

# Routes and Views:

@app.route("/")
def home():
    return render_template('index.html')

@app.route("/about/")
def about():
    return render_template('about.html')

@app.route("/page1/")
def page1():
    return render_template('page1.html')

# run flask server:
if __name__ == '__main__':
    app.run()

Wird der Server nun gestartet und im Browser die einzelnen Seiten der Applikation aufgerufen werden die html-templates für die entsprechende Seite gerendert.

Die Möglichkeiten zum nutzen von Templates sind schier endlos für Flask und bieten viel Raum für eigene Ideen und Umsetzungsmöglichkeiten in der Webentwicklung.

Fazit

Flask ist eine tolle Möglichkeit zum Einstieg in die Webentwicklung und bietet vielseitige Umsetzungsmöglichkeiten für Applikation, Websites oder APIs. Zudem ist es einfach zu lernen. Die dahinter stehende Community, die Umfangreiche Dokumentation, die Möglichkeit jedes Python Package miteinzubeziehen und die Masse an Tutorials bieten viel Raum um sich, Flask und die eigene App zu entwickeln/weiterzuentwickeln. Ohne das Flask dabei den Entwickelnden Rahmenbedingungen aufzwingt. Zusätzlich ist Lernkurve recht klein und der Entwickler wächst schnell in die Anforderungen und Möglichkeiten hinein.

  1. Stender, Daniel (2017): Tropfen um Tropfen. In: Entwickler Magazin, Jg. 2017, H. 6. Online unter: https://kiosk.entwickler.de/entwickler-magazin/entwickler-magazin-6-2017/tropfen-um-tropfen/ [Abruf am 10.01.2021]
  2. Stender, Daniel (2017): Tropfen um Tropfen. In: Entwickler Magazin, Jg. 2017, H. 6. Online unter: https://kiosk.entwickler.de/entwickler-magazin/entwickler-magazin-6-2017/tropfen-um-tropfen/ [Abruf am 10.01.2021]
  3. The Pallets Project (2020): Installation. Online unter https://flask.palletsprojects.com/en/1.1.x/installation/ [Abruf am 04.01.2021]
  4. The Pallets Project (2020): A minimal application. Online unter https://flask.palletsprojects.com/en/1.1.x/quickstart/#a-minimal-application [Abruf am 04.01.2021]
  5. The Pallets Project (2020): Routing. Online unter https://flask.palletsprojects.com/en/1.1.x/quickstart/#routing [Abruf am 04.01.2021]
  6. The Pallets Project (2020): Variable Rules. Online unter: https://flask.palletsprojects.com/en/1.1.x/quickstart/#variable-rules [Abruf am 04.01.2021]
  7. The Pallets Project (2020): Templating. Online unter: https://flask.palletsprojects.com/en/1.1.x/templating/ [Abruf am 04.01.2021]

Alle Codebeispiele sind selbst erarbeitet und getestet.


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Content Management (Wintersemester 2020/21, Prof. Dr.-Ing. Steinberg) entstanden.

Die besten Beiträge stellen wir Euch hier in den nächsten Wochen nach und nach vor.

Scrollytelling: Geschichte eines Unternehmens

Beitragsbild Scrollytelling - Geschichte eines Unternehmens

Autorinnen: Maria Sael  & Jeanice Noraman 


Inhalt

Einleitung

Jedes Unternehmen hat eine Geschichte, diese wird häufig auf der Unternehmenswebsite dargestellt. Doch wie kann man sich als Unternehmen von anderen abheben und die (potenziellen) Kunden und User ansprechen?

Eine Möglichkeit, um das zu erreichen ist das sogenannte “Scrollytelling”, bei dem Storytelling auf eine interaktive und kreative Ebene gehoben wird. Dem User wird mithilfe von unterschiedlichen Scroll-Techniken eine Geschichte auf eine neue und interessante Art übermittelt.

Einige Beispiele von Scrollytelling auf hohem Niveau:

Als Hilfestellung und Inspiration hat uns das Youtube-Video “Apple Airpod Pro Javascript Animation Tutorial” von Dev Ed gedient.

Konzept

Um die „Über uns“-Seite des Unternehmens „Cleantaxx“ spannender und interaktiver zu gestalten, kann der User durch die Implementierung von Scrollytelling die Seite selbst steuern. Durch Scrollen wird die Geschichte des Unternehmens erzählt, so dass der User auf die Reise in die Geschichte von Cleantaxx mitgenommen wird und sich ein Bild über das Unternehmen machen kann.

Das Ziel ist es, die Informationen auf interaktive Art zu vermitteln und den User zu ermutigen weiter zu scrollen und ihn zu animieren bis zum Ende dranzubleiben. Dabei sollen die Informationen weiterhin auf eine seriöse Art übermittelt werden.

Aufbau

Der User wird mit einem Intro-Video begrüßt, das er selbst durch Scrollen steuert. Beim Runterscrollen wird das Video abgespielt und durch Hochscrollen kann es wieder zurückgespult werden. Danach erhält der User mit einem kurzen Text die wesentlichen Informationen über das Unternehmen.

Scrollytelling Bild 1
Header und Intro

Anschließend beginnt die Unternehmensgeschichte, wobei man auch diese selbst steuert. Beginnend mit dem Jahr 2009 kann der User durch Scrollen die wichtigsten Ereignisse des Unternehmens erscheinen lassen. Auf der Reise durch die Unternehmensgeschichte wird der User von einem grünen Punkt auf der Timeline begleitet. Die blauen Punkte zeigen die wichtigsten Ereignisse im Verlauf der Jahre an, die erscheinen wenn man runterscrollt.

Scrollytelling Bild 2
Item auf der Timeline

Code

HTML

Da wir uns auf die Animation konzentrieren wollen und uns nicht mit dem Aufbau einer gesamten Website beschäftigen wollen ist der Header nur beispielhaft als Screenshot im Code eingefügt.

Der Content befindet sich innerhalb des Bodys in div-containern, angefangen mit dem Intro-Video und einem Text in der Mitte des Videos (welcher mithilfe von JavaScript durch scrollen verschwindet).

<!--Beispielhafter Header-->
  <header>
    <div class="container">
      <img src="Medien/header.png">
    </div>
  </header>

  <body>
    <!--Intro mit Video-->
    <div class="intro">
      <h1>Wer wir sind</h1>
      <video src="Medien/cleantaxxIntro.mp4" type="video/mp4"></video>
    </div>

Nach dem Video folgt ein Block mit einer kurzen Einführung zum Unternehmen und anschließend ist die Timeline platziert. Diese enthält in div-containern mit der Klasse “timeline-item” die Boxen links und rechts vom Zeitstrahl. Auf der Timeline haben wir für jedes timeline-item ein Timeline-Icon erstellt, welches ein wichtiges Ereignis darstellt. Im div “timelineContent” ist für jedes Ereignis die Jahreszahl, ein Bild und ein Text angegeben. Mithilfe der id’s “content1” etc. identifizieren wir im JS-Teil die Boxen, um sie pinnen zu können. Die fadeIn Klassen sind ebenfalls für den JS-Teil wichtig, damit wir die verschiedenen Elemente nacheinander erscheinen lassen können.

<!--Info übers Unternehmen-->
    <div class="container">
      <div id="info">
        <h1>Unternehmen</h1>
        <h2> Cleantaxx gehört in der Branche zu den Unternehmen mit der meisten Erfahrung im Bereich der Rußfilterreinigung. Jeden Tag liefern wir eine umweltschonende Alternative zum Neukauf. Trotz der anhaltenden positiven Entwicklung mit dem stetigen Wachstum sind wir ein flexibles, wegweisendes Unternehmen mit flachen Hierarchien geblieben. </h2>
      </div>

      <div id="timeline">
        <!--Box für Jahr 2009-->
        <div class="timelineItem">
          <div class="timelineIcon2"></div>
          <div class="timelineIcon"></div>
          <div class="timelineContent" id="content1">
            <h2>2009</h2>
            <img class="fadeIn" src="https://i.ibb.co/5xRmdw2/benjamin-kleemann-cleantaxx-geschaeftsfuehrer.jpg">
            <p class="fadeIn">Benjamin Kleemann gründete im Jahr 2009 nach einem Jahr Marktforschung das Unternehmen Cleantaxx. Geschaffen wurde damit ein unabhängiger Dienstleister für die Reinigung von Dieselpartikelfiltern (DPF). Das Unternehmen bietet seitdem maßgeschneiderte Lösungen für Hersteller, Händler, Werkstätten und Anwender. Gereinigt werden alle Dieselpartikelfilter, herstellerübergreifend vom PKW bis zum Schiff – für alles was mit einem Dieselmotor angetrieben wird. Die Säulen der Cleantaxx-Reinigung bilden eine taggleiche Logistik, eine umfangreiche Prüfung und Dokumentation, sowie eine zertifizierte und schonende Reinigung innerhalb 24 Stunden.
            </p>
          </div>
        </div>

Die beschriebene Vorgehensweise haben wir für jedes Ereignis angewendet. Im Body haben wir außerdem die verschiedenen JS-libraries bzw. Plugins angegeben, die wir verwenden wollen. Abschließend haben wir einen beispielhaften Footer eingefügt.

<script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.7.1/gsap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.7.1/ScrollTrigger.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/ScrollMagic/2.0.7/ScrollMagic.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/ScrollMagic/2.0.7/plugins/animation.gsap.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/ScrollMagic/2.0.7/plugins/debug.addIndicators.js"></script> <!-- später rausnehmen-->
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/2.1.3/TweenMax.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/2.1.3/TweenLite.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/2.1.3/TimelineLite.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/2.1.3/plugins/CSSPlugin.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/2.1.2/plugins/BezierPlugin.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/gsap/3.7.1/MotionPathPlugin.min.js"></script>

    <script src="app.js"></script>
  </body>
  <!--Beispielhafter Footer-->
  <footer>
    <img src="Medien/footer.png">
  </footer>

CSS

Um das Layout unserer Webseite zu formatieren, haben wir ein externes CSS-Stylesheet verwendet. Mithilfe des CSS-Stylesheet können wir Bilder, Box, Container, Video, Header, Textkörper, Links und Logogröße, Farbe und Stil, Aussehen und Positionierung der Timeline sowie den Abstand zwischen Elementen steuern und angeben, wie Elemente positioniert und angeordnet werden sollen. Box-sizing, html Seite, Body und Footer

* {
  box-sizing: border-box;
}

body, html {
  height: 100%;
}

body {
  background: #f9f9f9;
  background-size: cover;
  margin: 0;
  padding: 0;
  font-family: helvetica, arial, tahoma, verdana;
  line-height: 20px;
  font-size: 14px;
  color: black;
}

footer {
  position:relative;
  width: 100% ;
  height:auto;
  overflow: hidden;
}

Intro Formatierung

/**********Intro*******/
.intro {
  height: 100vh;
}

.intro video {
  height: 100%;
  width: 100%;
  object-fit: cover;
  z-index:1;
}

.intro h1 {
  position: absolute;
  top: 50%;
  left: 50%;
  transform: translate(-50%, -50%);
  font-size: 80px;
  color: #2c5697;
}

Images, Hyperlinks, Container

img {
  max-width: 100%;
}

a {
  text-decoration: none;
}

.container {
  max-width: 1100px;
  margin: 0 auto;
}

/*****Überschriften*****/
h1, h2, h3, h4 {
  font-family: "Dosis", arial, tahoma, verdana;
  font-weight: 500;
}

Infobox

/*****Info Box*****/
#info {
  display: block;
  margin-left: 180px;
  margin-right: 180px;
  margin-bottom: 50px;
}

#info h1 {
  text-align: center;
  padding: 10px 0;
  color: #2c5697;
}

#info h2 {
  font-weight: lighter;
  text-align:center;
}

Die gesamte Timeline-Struktur wurde ebenfalls mit CSS erstellt, indem man die Timeline-Breite, Farbe, Länge, Position, Paddings und Margins definiert und die Boxen an den Seiten der Linie anordnet und zwischen den linken und rechten Containern unterscheidet, indem man sie auf eine andere Klasse definiert.

/*****Timeline*****/
#timeline {
  width: 100%;
  margin: 30px auto;
  position: relative;
  padding: 0 10px;
  content: "";
  clear: both;
  display: table;
}

#timeline:before {
  content: "";
  width: 3px;
  height: 100%;
  background: #2c5697;
  left: 50%;
  top: 0;
  position: absolute;
}

#timeline .timelineItem {
  margin-bottom: 50px;
  position: relative;
  overflow: hidden;
}

/**Punkte auf Timeline**/
#timeline .timelineItem .timelineIcon {
  background: #2c5697;
  width: 50px;
  height: 50px;
  position: absolute;
  top: 0;
  left: 50%;
  overflow: hidden;
  margin-left: -23px;
  border-radius: 50%;
}

#timeline .timelineItem .timelineIcon svg {
  position: relative;
  top: 14px;
  left: 14px;
}

/**Grüner Punkt auf Timeline**/
#timeline .timelineItem .timelineIcon2 {
  background: #3ea838;
  width: 50px;
  height: 50px;
  position: absolute;
  top: 0;
  left: 50%;
  overflow: hidden;
  margin-left: -23px;
  border-radius: 50%;
}

#timeline .timelineItem .timelineIcon2 svg {
  position: relative;
  top: 14px;
  left: 14px;
}

/*******Content auf Timeline*******/
#timeline .timelineItem .timelineContent {
  width: 45%;
  background: #fff;
  padding: 20px;
  box-shadow: 0 3px 0 rgba(0, 0, 0, 0.1);
  border-radius: 5px;
  transform: translateX(50%);
}

#timeline .timelineItem .timelineContent h2 {
  padding: 15px;
  background: #2c5697;
  color: #fff;
  margin: -20px -20px 0 -20px;
  font-weight: 300;
  border-radius: 3px 3px 0 0;
}

#timeline .timelineItem .timelineContent.right {
  float: right;
  margin-left: 55%;
  transform: translateX(-50%);
}

Wir haben auch in den CSS-Dateiklassen definiert, die zu einigen Elementen hinzugefügt werden müssen, um Animationen von JavaScript aus anzuwenden. Zum Beispiel die Klasse “appear”, die hinzugefügt wird, damit die Elemente mit der Klasse eingeblendet werden, indem die Deckkraft des Elements mit Leichtigkeit (Opacity) von 0 auf 1 geändert wird.

Die “appear”-Klasse wird auch Elementen mit der Klasse timelineContent hinzugefügt, um sie mit einem Einblendeffektnach rechts und links und umgekehrt durch Ändern der Deckkraft und der Transformationsachse gleiten zu lassen.

/*****Fade in*****/
#timeline .timelineItem .timelineContent,
#timeline .timelineItem .timelineContent.right {
  transition: opacity 250ms ease-in, -webkit-transform 400ms ease-in;
  transition: opacity 250ms ease-in, transform 400ms ease-in;
  transition: opacity 250ms ease-in, transform 400ms ease-in,
    opacity: 0;
}

#timeline .timelineItem .timelineContent.appear,
#timeline .timelineItem .timelineContent.right.appear {
  transform: translateX(0);
  opacity: 1;
}

.fadeIn {
  opacity: 0;
  transition: opacity 250ms ease-in;
}

.fadeIn.appear {
  opacity: 1;
}

JavaScript

Content einsliden

Die gewünschte Funktion in diesem Code besteht darin, das “Timeline content -div” aus der Richtung des Punktes in der Timeline an seinen Platz gleiten zu lassen und den darin enthaltenen Inhalt (das Bild und den Text) erscheinen zu lassen, sobald der Inhalt nach unten gescrollt wurden.

Um diese Funktion in JavaScript zu erreichen, haben wir das IntersectionObserver() “Interface” (eine Art von Objekt) verwendet. Der IntersectionObserver()-Konstruktor erstellt ein neues IntersectionObserver-Objekt und gibt es zurück. Es benötigt zwei Parameter: callback und options (optional).

Callback-Parameter: Eine Funktion, die aufgerufen wird, wenn der Prozentsatz des Zielelements sichtbar ist, einen Schwellenwert” threshold” überschreitet. Der Callback erhielt als Eingabe zwei Parameter: entries und Observer.

  • entries: Ein Array von IntersectionObserverEntry-Objekten, von denen jedes einen überschrittenen ” threshold” darstellt und entweder sichtbar wird als der durch diesen ” threshold” angegebene Prozentsatz.
  • Observer: Der IntersectionObserver, für den der Rückruf aufgerufen wird.

Options-Parameter: Ein optionales Objekt, das den observer anpasst.

  • rootMargin: Um sicherzustellen, dass es syntaktisch korrekt ist
  • thresholds: Um sicherzustellen, dass sie alle im Bereich von 0,0 bis einschließlich 1,0 liegen.

In der Callback-Funktion haben wir eine foreach-Schleife definiert, die jeden Eintrag “Entry” durchläuft und prüft, ob der IntersectionObserver schneidet oder nicht. Und um Fehler zu vermeiden, geben wir die Funktion das Befehl “return”, falls sie sich nicht überschneidet. Aber wenn es sich überschneidet, soll die Funktion, die classList (appear) hinzuzufügen, die wir in CSS erstellt haben, die die Elemente erscheinen oder von links und rechts gleiten lässt. Danach haben wir die Funktion erstellt haben nachgerufen mit der (unobserved) Methode, damit die Funktion stoppt, sobald sie ihr definiertes Ziel erreicht.

//-----------fadeIn und von Seiten einsliden---------------
const faders = document.querySelectorAll(".fadeIn");
const sliders = document.querySelectorAll(".timelineContent");

const appearOptions = {
  threshold: 1,
  rootMargin: "0px 0px -50px 0px"
};

//-------------------observer für fadeIn--------------------
const appearOnScroll = new IntersectionObserver(function(
    entries,
    appearOnScroll
  ) {
    entries.forEach(entry => {
      if (!entry.isIntersecting) {
        return;
      } else {
        entry.target.classList.add("appear");
        appearOnScroll.unobserve(entry.target);
      }
    });
  },
  appearOptions);

  faders.forEach(fader => {
    appearOnScroll.observe(fader);
  });

Und weil die definierten Optionen zu schnell waren, um bemerkt zu werden, haben wir den Schwellenwert auf eins und den rootMargin auf: 0px 0px -50px 0px festgelegt Damit die Animation funktioniert, sobald wir zum Inhalt herunterscrollen.

Schließlich, um die Aktion zum Leben zu erwecken, wir rufen es mit einer ForEach-Schleife auf, die in die definierten Elemente (sliders und Faders) geht. und wendet die definierte Funktion (appearOnScroll und slideOnScroll) mit der Methode Observe an.

• sliders: wählt alle Elemente aus, die die Klasse “.timelineContent” haben • faders: wählt alle Elemente aus, die die Klasse “.fadeIn” haben

//------------------Einsliden Options----------------------
const sliderOptions= {
  threshold: 0,
  rootMargin: "0px 0px -50px 0px"
};
//------------Observer für von rechts und links------------
const slideOnScroll = new IntersectionObserver(function(
    entries,
    slideOnScroll
  ) {
    entries.forEach(entry => {
      if (!entry.isIntersecting) {
        return;
      } else {
        entry.target.classList.add("appear");
        slideOnScroll.unobserve(entry.target);
      }
    });
  },
  sliderOptions);

sliders.forEach(slider => {
  slideOnScroll.observe(slider);
});

Video-Animation

Um diese Animation umsetzen zu können werden verschiedene Libraries benötigt. Eine davon ist ScrollMagic, welche es ermöglicht auf Scroll zu animieren. Zusätzlich verwenden wir GSAP (genauer gesagt TweenMax), um den Text animieren zu können. Eine sinnvolle Hilfe die wir benutzt haben ist die das debug Plugin von ScrollMagic namens “addIndicators”, welches rechts am Bildschirm Indikatoren für die Trigger einfügt (wie der Name schon sagt).

Um ScrollMagic zu implementieren wird ein Controller im Code benötigt. Anschließend kann man anfangen die verschiedenen Szenen zu erstellen und dem Controller hinzuzufügen, wobei jede Szene ein Teil vom Code ist, den man animieren möchte.

Scrollytelling Bild 3
Indikatoren rechts

Die erste Szene beschäftigt sich mit der Animation des Videos. In der Szene gibt es verschiedene Optionen, wie die Dauer (wie viele Pixel soll gescrollt werden), das Trigger-Element (wann soll die Animation starten, wobei 0=oben, 0.5=Mitte, 1=unten) und die Trigger-Hook (wo auf dem Bildschirm soll das Element getriggert werden. Sobald der “Haken” auf das Element trifft, wird es animiert.

Anschließend muss die Szene durch “.addTo(controller);” dem Controller hinzugefügt werden. Um einen Pin zu setzen, damit das Video für die Dauer der Animation haften bleibt verwenden wir “.setPin(intro);”. Hier kann man ebenfalls die Indikatoren für Hook, Start und Ende mithilfe von “.addIndicators();” anzeigen lassen.

const intro = document.querySelector(".intro");
const video = intro.querySelector("video");
const text = intro.querySelector("h1");

//----------------------ScrollMagic-------------------------
const controller = new ScrollMagic.Controller();

//------------------------Szenen----------------------------
//------------------------Video-----------------------------
let scene = new ScrollMagic.Scene({
    duration: 5000,
    triggerElement: intro,
    triggerHook: 0
  })
  .addIndicators()
  .setPin(intro)
  .addTo(controller);

Nach allen Szenen animieren wir nun das Video, wozu wir einige Variablen benötigen. Da wir nicht wollen, dass das Video beim scrolleln abgehackt aussieht, programmieren wir einen ease-Effekt. Mithilfe von einem Delay, wird das Video nachdem man aufhört zu scrollen noch kurz weiter abgespielt.

  • accelamount = ease-Effekt am Ende (das was von den Frames noch übrig ist)
  • scrollpos = Wo gescrollt wird
  • delay = Soll aufholen wohin wir scrollen

(Um Sekunden zu erhalten, teilen wir die Scroll-Position durch 1000.) Als letztes setzen wir ein Intervall, in dem wir dem delay das hinzufügen was gescrollt wird und es um 0.1 beschleunigen. Um den ease-Effekt nun zu erhalten geben wir an, dass video.currentTime = delay sein soll.

//--------------------Video Animation-----------------------
let accelamount = 0.1;
let scrollpos = 0;
let delay = 0;

scene.on("update", e => {
  scrollpos = e.scrollPos / 1000;
});

setInterval(() => {
  delay += (scrollpos - delay) * accelamount;
  console.log(scrollpos, delay);

  video.currentTime = delay;
}, 43.5);

Um nun den Text zu animieren, sodass dieser nicht die ganze Zeit in der Mitte des Video bleibt, erstellen wir eine neue Szene. In der neuen Szene geben wir erneut an, wie weit gescrollt werden soll, was das Trigger-Element ist und wo die Trigger-Hook sein soll. Um es zu animieren brauchen wir Tweenmax, in dem wir angeben, dass der Text innerhalb von 3 Sekunden von einer opacity (Deckkraft) von 1 zu einer opacity von 0 gehen soll. In der soeben erstellten Szene setzen wir nun noch einen Tween, damit der Text nicht einach nach 3 Sekunden verschwindet, sondern durch scrollen verschwindet.

//---------------------Text Animation-----------------------
const textAnim = TweenMax.fromTo(text, 3, {opacity: 1}, {opacity: 0});

let scene2 = new ScrollMagic.Scene({
    duration: 3000,
    triggerElement: intro,
    triggerHook: 0
  })
  .setTween(textAnim)
  .addTo(controller);

Content anpinnen

Damit wir den Content, also die Boxen mit dem Inhalt, anpinnen können, brauchen wir jeweils eine ScrollMagic-Szene pro Box. Wie auch schon bei der Szene des Videos, geben wir die Dauer, das Trigger-Element und die Position der Trigger-Hook an. In diesem Fall wollen wir, dass jede Box für 300 Pixel angepinnt wird (es also trotz scrollen hängen bleibt). In jeder Szene ordnen wir dem Trigger-Element die entsprechende ID zu, sodass die Boxen nacheinander angepinnt werden.

//---------------------Pin Content--------------------------
var scene4 = new ScrollMagic.Scene({
    duration: 400,
    triggerElement: "#content1",
    triggerHook: 0.1
  })
  .setPin("#content1")
  .addIndicators({name: "1 (duration: 400)"})
  .addTo(controller);

var scene5 = new ScrollMagic.Scene({
    duration: 400,
    triggerElement: "#content2",
    triggerHook: 0.1
  })
  .setPin("#content2")
  .addIndicators({name: "2 (duration: 400)"})
  .addTo(controller);

//-----------------Und so weiter...--------------------

Die gleiche Methode verwenden wir auch, um den grünen Punkt in der Mitte anzupinnen und mitlaufen zu lassen.

//----------------------Pin Punkt---------------------------
var scene3 = new ScrollMagic.Scene({
    duration: 6200,
    triggerElement: ".timelineContent",
    triggerHook: 0.1
  })
  .setPin(".timelineIcon2")
  .addIndicators({name: "Punkt"})
  .addTo(controller);

Anmerkung

Das in unserer Animation verwendete Unternehmen Cleantaxx weiß von unserem Projekt, wir haben es jedoch nicht in Zusammenarbeit mit dem Unternehmen erstellt, sondern eigenständig und rein für unsere MM-SYS Abgabe. Wir sind nicht Urheber des Contents, welches wir in der Animation verwendet haben, haben jedoch die Erlaubnis bekommen den Content ihrer Seite zu verwenden. Nach Absprache mit uns dürfte das Unternehmen Cleantaxx die Animation zu eigenen Zwecken verwenden, falls gewünscht.

Quellen


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Entwicklung von Multimediasystemen (Sommersemester 2021, Amy Linh Hoang,  Prof. Dr.-Ing. Steinberg) entstanden. Verwendete Techniken sind HTML5, CSS3 und JavaScript. Die besten Tutorials stellen wir Euch hier in den nächsten Wochen nach und nach vor.

Tutorial: Mini Game “Magic Garten” – Blumen pflanzen als interaktive Animation

eitragsbild Tutorial: Mini Game “Magic Garten” - Blumen pflanzen als interaktive Animation

Autorinnen: Maria Olberg  und Elisabeth Rutt 


In diesem Tutorial zeigen wir, wie man eine interaktive Animation entwickeln kann. Wir stellen dazu unsere Animation vor und gehen auf das Konzept, Techniken und Besonderheiten der Animation sowie Ausschnitte des Quellcodes ein.

Link zur Animation

ZIP-Ordner zum Downloaden

Inhaltsverzeichnis

Das Konzept unserer Animation

Bei unserer Animation handelt es sich um das kleine, interaktive Spiel “Magic Garten”, durch das sich der User mit Hilfe von Buttons weiter klicken kann. Das Ziel des Spiels ist es, Blumen in einem Garten zu pflanzen und diese wachsen zu lassen. Dabei kann man zwischen drei verschiedenen Arten von Blumen wählen. Außerdem können die Blumen u.a . auch mit Hilfe einer Gießkanne gegossen werden, damit sie weiter wachsen.

Die Idee zu dieser Animation kam dadurch, dass wir, unabhängig von der Person, die es spielt, für jeden User einen interessanten Zeitvertreib für Zwischendurch entwickeln wollten. Vor allem, soll sie aber Kindern Spaß machen. Die Darstellung der Elemente ist im Comic-Stil gehalten und die Hintergrundmusik verstärkt den Spiele-Charakter.

Das Ziel der Animation ist es, den User mit Hilfe von interaktiven Elementen durch die einzelnen Schritte des Spiels zu führen, damit er im Magic Garten die Blumen pflanzen kann. Dazu gibt es einen helfenden Charakter: eine Biene “Maja”, die den User mit hilfreichen Informationen zu den jeweiligen Schritten des Spiels versorgt. Über die interaktiven Buttons gelangt er entweder zum nächsten Schritt des Spiels oder erhält Anweisungen, was im jeweiligen Schritt zu tun ist. Die Anweisungen erscheinen mit Hilfe von visuellen Effekten in einer Sprechblase.

Insgesamt erfüllt die Animation daher zwei Funktionen: Die erste Funktion bezieht sich auf den Inhalt der Animation und ist das Spiel an sich, bei dem der User die Blumen einpflanzen und wachsen lassen soll sowie das Erzählen der Story, indem sich der User durch die einzelnen Szenen klickt. Die zweite Funktion ist die Optik, die den User zum Spielen animieren soll. Dafür wurden Elemente und visuelle Effekte eingebaut, die das Spiel attraktiver gestalten, wie z. B. die Biene, die den User durch das Spiel begleitet und die lachende Sonne, die über den Garten scheint.

Die Animation besteht aus 4 Szenen, die den User vom Intro bis zu den fertig gewachsenen Blumen leiten. Außerdem sind im Spiel auch Entscheidungen für den User eingebaut, die den weiteren Verlauf der Animation bestimmen.

Aufbau der Animation

Die Animation besteht insgesamt aus 4 aufeinander folgenden Szenen:

Erste Szene: Start und Intro

Der erste Teil der Animation ist der Startbildschirm mit dem Titelbild des Spiels. Hier befindet sich der “Play”-Button, über den der User zur ersten Szene gelangt. Zu Beginn erscheint die Biene “Maja”, die sich vorstellt dem User eine kurze Einführung in das Spiel gibt. Anschließend fordert sie ihn dazu auf, mit dem Spiel zu beginnen und Blumen zu pflanzen. Dazu erscheint der Button “Blumen auswählen”, über den der User in die zweite Szene gelangt, um die Art der Blume, die er pflanzen möchte, auszuwählen.

MagicGarten Bild
Weiterführender Button zum Auswählen der Blumen

Zweite Szene: Auswählen und Pflanzen von Blumen

Sobald der User auf “Blumen auswählen” geklickt hat, erscheinen drei Beutel mit verschiedenen Blumensamen, die Lieblingsblumen von Maja. Jeder Beutel zeigt auch das Bild der jeweiligen Blume. Fährt der Spieler mit der Maus über die Bilder der Blumen, sagt Maja auch etwas zu der jeweiligen Blumenart über ihre Sprechblase. Unter jedem Beutel gibt es den Button “Auswählen” und mit einem weiteren Klick auf den ausgewählten Beutel beginnt das Einpflanzen. Der Beutel beginnt anschließend, die Samen automatisch im Garten zu pflanzen und es sprießen bereits kleine Pflanzen.

MagicGarten2
Der User hat die Wahl zwischen drei Blumensorten

Dritte Szene: Blumen gießen und wachsen lassen

Während des Spiels gibt Maja hilfreiche Tipps zum Spielverlauf. In dieser Szene freut sie sich über die eingepflanzten Blumen und macht auf die Gießkanne aufmerksam, mit der der User die Blumen gießen kann, damit sie wachsen. Der User kann sie Gießkanne anklicken, um sie hoch zu heben und mit der Maus anschließend darüber fahren, um mit dem Gießen zu beginnen. Als nächstes gibt Maja den Tipp, die Blumen nun in der Sonne weiter wachsen zu lassen. Dazu kann der User nun auf die Sonne klicken, die daraufhin beginnt, stärker zu scheinen und über das Blumenfeld zu wandern. Anschließend bietet Maja einen Magic Booster an, um die Blumen doppelt so stark wachsen zu lassen. Der User kann hier zwischen “Ja” und “Nein” auswählen. Je nach dem, welche Antwort der User wählt, ändern sich die Animation und die Reaktion von Maja.

MagicGarten3
Der User wählt beispielhaft Sonnenblumen aus
MagicGarten4
Der User kann die Blumen gießen und durch die Sonne wachsen lassen

Vierte Szene: Outro

In der vierten Szene spielt der User nicht mehr aktiv mit. Maja beginnt mit Hilfe einer Animation über die Blumenwiese zu fliegen. Zum Schluss bedankt sie sich für die Hilfe des Users und schenkt ihm als Dank ein Glas mit Honig. An dieser Stelle ist die Animation beendet und es erscheint der Button “Restart”, wodurch die Seite neu geladen wird und der User wieder zum Intro gelangt.

MagicGarten5
Schlussszene: Maja bedankt sich für die Hilfe und der User kann das Spiel neu starten

Der Quellcode

Verwendete Programmiersprachen für die Animation sind HTML5, CSS3, JavaScript und jQuery. HTML wird für die Gestaltung sowie den Grundaufbau der Seite und des Spiels genutzt. CSS sorgt für die richtige Positionierung, Style-Anpassungen und mit Hilfe von keyframes auch für die kleine Animationen und visuelle Effekte.

Mit Hilfe von JavaScript werden die Objekte je nach Auswahl der Story-Optionen angezeigt bzw. versteckt, der Text bei den Hover-Effekten geändert, die Auswahl der Blumensorte für den weiteren Verlauf des Spiels gespeichert und die Index-Datei so umgeschrieben, dass sie sich automatisch angepasst hat. Außerdem erscheinen die Objekte durch JavaScript nach bestimmten Zeitangaben für ein optimales Spielerlebnis, wie z. B. die automatische Änderungen des Textes und die Bewegung der Gießkanne nach einigen Sekunden. Die Seite besteht aus drei DIV-Containern: Der erste zeigt die Überschrift “Magic Garten”, der zweite das Spielfeld und der dritte zeigt einen Untertitel.

<body>
    <script src="animation.js"></script> <!--Einbindung der JavaScript Datei--> </div>
    <div class="header"> <!--Div-Container wird angezeigt nach dem Spielstart--></div>
    <div id="animation_feld" class="animation_null"> <!--Hauptbereich: interaktives Spiel--></div>
    <div class="biene"> <!--Intro des Spieles und Platziereung der Beiene während des ganzen Spiel--></div>
<div class="footer"> <!--Unterbereich mit Autorennamen und versteckte Audio--> </div> </body>
Beispiel für DIV-Container im Quellcode

Gestaltung von besonderen Elementen

Innerhalb der Animation gibt es verschiedene interaktive Elemente, die sich mit Hilfe von Animationen durch die Szenen bewegen und gewisse Aktionen auslösen.

Die verwendeten Bilder sind im PNG-Format und stammen von Pixabay. Die Überschrift und der Untertitel sowie die fertig gewachsenen Blumen wurden selbst in Photoshop erstellt. Damit die Bilder optimal angezeigt werden, wurde der z-Index verwendet. Dieser unterscheidet sich bei den Bildern der jeweiligen Szenen und man sollte ihn so anpassen, dass Bilder möglichst gut dargestellt werden.

Bewegende Elemente und visuelle Effekte

Maja

Damit Maja dem User durch das Spiel helfen kann, wird sie durch von Keyframes zum Leben erweckt. Mit Hilfe des JavaScript Befehls .show() und .hide() wird sie passend zur jeweiligen Szene eingesetzt bzw. versteckt. Hierbei gibt es drei verschiedene Keyframe Animationen: Zuerst bewegt sich Maja vom Startbildschirm nach unten auf das folgende Bild, sobald der User das Spiel startet. Damit sie ihn mit nützlichen Informationen durch das Spiel führen kann, erhält sie Sprechblasen, die mit Hilfe der Anweisung

setTimeout(function() {$("#rede_1").css({"visibility": "visible"});}, 2000); 

angezeigt und mit bspw.

setTimeout(function() {$("#text_1").hide();$("#text_2").css({"visibility": "visible"});}, 500); 

nach 5 Sekunden automatisch geändert werden. Die Zeit, nach der sich die Animationen ändern, variiert hier während des Spiels und kann nach Belieben angepasst werden, damit man die Texte gut lesen kann.

    /*Biene startet das Gespräch mit dem User*/
    setTimeout(function() {
        $("#rede_1").css({"visibility": "visible"});
    }, 2000);
    setTimeout(function() {
        $("#text_1").css({"visibility": "visible"});
    }, 2500);
});	
$("#link_1").on("click", function () {
    setTimeout(function() {
        $("#text_1").hide();
        $("#text_2").css({"visibility": "visible"});
    }, 500);
    setTimeout(function() {
        $("#button_choose").css({"visibility": "visible"});
    }, 1500);
});
Einblenden und Verstecken der Sprechblase für Maja

Die zweite Keyframe Animation lässt Maja auf dem nächsten Bild nach oben wirbeln. Diese Animation wird mit Hilfe des Befehls

$("#honey_biene_2").css({"animation-play-state": "running"}); 

ausgelöst, sobald der User den Button “Blumen auswählen” anklickt. Hier werden die Texte in der Sprechblase wieder mit dem oben stehenden Befehl angezeigt und geändert (die konkreten Befehle ändern sich etwas je nach Text).

/*Übergang zur Szene #1.2
    Start des aktiven Spiels mit Anweisungen an den Spieler
    Elemente werden durch Änderungen des Styles angezeigt oder durch 
    jQuery Funktionen*/
$("#button_choose").on("click", function() {
    $("#button_choose").css({"visibility": "hidden"});
    $("#choose").hide();
    $("#rede_1").css({"visibility": "hidden"});
    $("#text_2").hide();
    $("#honey_biene").css({"visibility": "hidden"});
    $("#honey_biene_2").show();
    $("#honey_biene_2").css({"animation-play-state": "running"});
    setTimeout(function() {
        $("#rede_2").css({"visibility": "visible"});
    }, 1700);
    setTimeout(function() {
        $("#text_3").css({"visibility": "visible"});
    }, 2200);
    $(".sack").fadeIn(3000);
    setTimeout(function() {
        $(".blumen_choose").show();
    }, 3000);
Visuelle Effekte für Maja

Die dritte Keyframe Animation lässt Maja zum Ende des Spiels über die Blumenwiese fliegen. Mit Hilfe von translateX() bewegt sie sich hin und her und mit scaleX() dreht sie sich während der Animation um, um in die jeweils andere Richtung zu fliegen. Dabei wird das Bild gespiegelt. Ist der Magic Booster nicht ausgewählt, fliegt Maja standardmäßig durch die Eigenschaft animation-iteration-count: 1; einmal Hin und Her. Wenn der Magic Booster ausgewählt ist, dann fliegt sie zweimal Hin und Her. Dies wird mit Hilfe einer if-Anweisung angepasst.

/*Style Eigenschaften für die Biene im Outro.
Die keyframe-Animation für die fliegende Biene. In JS ist die Anpassung je nach
Antwort des Users*/

#biene_fly {
    position: absolute;
    z-index: 15;
    height: 15%;
    bottom: 60%;
    left: 22%;
    display: none;
    
    animation-name: bee_fly; 
    animation-duration: 5s;
    animation-timing-function: ease;
    animation-delay: 0s;
    animation-iteration-count: 1;
    animation-fill-mode:forwards;
    animation-play-state: running;
}

@keyframes bee_fly {
    0%  { transform: translateX(0px) scaleX(-1)}
    25%	{ transform: translateX(380%) scaleX(-1)}
    50%	{ transform: translateX(380%) scaleX(1)}
    100%  { transform: translateX(-10%) scaleX(-1)}
    
}
Style-Anpassungen für Maja im Outro
if ($(".plant_small").attr("src")==("media/Magic_Rose.png") || $(".plant_small").attr("src")==("media/Magic_Sunflower.png") || $(".plant_small").attr("src")==("media/Magic_Poppy.png")) {
    $("#biene_fly").css({"animation-iteration-count": "2"});
}
if-Anweisung bei der Auswahl des Magic Boosters

Säcke mit Blumensamen

Der Hover-Effekt bei den Blumensäcken wird mit der Anweisung $(“#rose_sack”).mousemove() erzeugt. So ändert sich der Text in der Sprechblase, wenn man mit der Maus über ein bestimmtes Element (in dem Fall ist es die Rose) fährt. Verlässt man mit der Maus diese Stelle wieder, wird der Text mit dem Befehl $(“#rose_sack”).mouseout() wieder automatisch geändert.

/*Information über Blumensorten erscheint, wenn die Maus auf dem Bild ist,
    und verschwindet, wenn die Maus weg ist*/
$("#rose_sack").mousemove(function(evt) {
    $("#text_3").css({"display":"none"});
    $("#text_4").css({"visibility": "visible","display":"block"});	
});
$("#rose_sack").mouseout(function(evt) {
    $("#text_4").css({"display":"none"});
    $("#text_3").css({"display":"block"});
});
$("#sun_sack").mousemove(function(evt) {
    $("#text_3").css({"display":"none"});
    $("#text_5").css({"visibility": "visible","display":"block"});	
});
$("#sun_sack").mouseout(function(evt) {
    $("#text_5").css({"display":"none"});
    $("#text_3").css({"display":"block"});
});
$("#mohn_sack").mousemove(function(evt) {
    $("#text_3").css({"display":"none"});
    $("#text_6").css({"visibility": "visible","display":"block"});	
});
$("#mohn_sack").mouseout(function(evt) {
    $("#text_6").css({"display":"none"});
    $("#text_3").css({"display":"block"});
});
Auswahl der Blumensorte mit Hover-Effekt

Nach der Auswahl der Blumesorte verschwinden durch die Anweisungen $(“.sack”).fadeOut(1200); und $(“.blumen_choose”).hide();  die Bilder der Säcke, die nicht ausgewählt wurden und der ausgewählte Sack erscheint in der Mitte.

$(".sack").fadeOut(1200);
$(".blumen_choose").hide();

/*Je nach Auswahl wird der Sack mit der richtigen Blume angezeigt. Animation an sich
    ist gleich und startet beim Klick auf jeweiliges Bild*/		
switch (blume) {
    case "Rose":
    setTimeout(function () {
        $(".rose").show();
        $("#sack_blume_rose").on("click", function () {
            $(".sack_blume").css({"animation-play-state": "running"});
            $(".oat_raw").css({"animation-play-state": "running"});
            setTimeout(function () {
                $(".rose").hide();
                $("#text_7").css({"display":"none"});
                $("#text_8").css({"visibility": "visible","display":"block"});
            }, 7200);
        })
    }, 1500);
    break;
Visuelle Effekte für die Blumensäcke

Beim Klick auf den Sack wird die Keyframe Animation aktiviert, wodurch er sich bewegt, um die Blumensamen auf der Wiese zu verteilen. Die Anweisung besteht aus 7 Schritten, in denen translateX(), translateY() und rotate() verwendet werden,sodass er sich zum Verteilen über die Wiese bewegt und dabei auch die Ausrichtung nach links und rechts ändert. Bei der Anweisung für die Blumensamen, die aus dem Sack in die Erde fallen, benutzt man zusätzlich scale(). Nachdem die Animation fertig abgespielt ist und damit die Samen verteilt sind, verschwindet der Sack automatisch.

/*Positionierung und Animation für alle Säcke in der Szene sind gleich*/

.sack_blume {
    position:absolute;
    top: 50%;
    left: 40%;
    height: 30%;
    z-index: 11;
    cursor:pointer;
    
    animation-name: sack_hoch; 
    animation-duration: 7s;
    animation-timing-function: ease;
    animation-delay: 0s;
    animation-iteration-count: 1;
    animation-fill-mode:forwards;
    animation-play-state: paused;
}

/*Animation mit mehreren Bewegungen*/
@keyframes sack_hoch {
    from  { transform: translateX(0px) translateY(0px)}
    18%	{ transform: translateX(-100px) translateY(-250px) rotate(-90deg)}
    36%	{ transform: translateX(-325px) translateY(-130px) rotate(-120deg)}
    52%	{ transform: translateX(100px) translateY(-250px) rotate(-120deg)}
    70%	{ transform: translateX(100px) translateY(-130px) rotate(-120deg)}
    88% { transform: translateX(350px) translateY(-250px) rotate(120deg)}
    to  { transform: translateX(400px) translateY(-130px) rotate(120deg)}
}
Anpassungen für die Animation der Blumensäcke
/*Positionierung und Animation für Blumensamen in der Szene sind gleich
Die Animation wiederholt die Bewegung des Sackes, mit der Ausnahme beim vorletzten
Schritt:
    Blumensamen verschwinden und erscheinen am Ende, wänhrend Sack sich umdreht*/
.oat_raw {
    position:absolute;
    top: 51%;
    left: 46%;
    height: 10%;
    z-index: 12;
    
    animation-name: oat_hoch; 
    animation-duration: 7s;
    animation-timing-function: ease;
    animation-delay: 0s;
    animation-iteration-count: 1;
    animation-fill-mode:forwards;
    animation-play-state: paused;
}

/*Animation mit mehreren Bewegungen*/

@keyframes oat_hoch {
    from  { transform: translateX(0px) translateY(0px)}
    18%	{ transform: translateX(-150px) translateY(-180px) rotate(-90deg)}
    36%	{ transform: translateX(-375px) translateY(-40px) rotate(-120deg) scale(0.85)}
    52%	{ transform: translateX(50px) translateY(-140px) rotate(-120deg) scale(0.75)}
    70%	{ transform: translateX(50px) translateY(-50px) rotate(-120deg) scale(0.7)}
    88% { transform: translateX(390px) translateY(-180px) rotate(120deg)scale(0.0)}
    to  { transform: translateX(465px) translateY(-40px) rotate(120deg) scale(0.65)}
}

Positionierung und Animation der Blumensäcke

Wachsende Blumen

Die Blumen wachsen in dem Spiel mit Hilfe einer Animation mittels JavaScript. Dazu gibt es für die verschiedenen Stadien des Wachstums verschiedene Bilder, die automatisch mit Hilfe von Anweisungen, wie bspw. $(“.plant_small”).attr(“src”, “media/grass.png”); ausgetauscht werden und anschließend durch die Anweisung $(“.plant_small”).css({“animation-play-state”:”running”}); animiert werden. Dadurch verändert sich das Wachstum der Blumen durch Animationen im Laufe des Spiels automatisch. Die Auswahl der Blumensorte zu Beginn des Spiels wird mit Hilfe einer Switch-Anweisung für den restlichen Spielverlauf übernommen

        /*Funktion für Blumen. Bilder sind von der Auswähl abhängig*/
        switch (blume) {
            case "Rose":
                $(".plant_small").attr("src", "media/Rose_Bush.png");
                break;
            case "Sonnenblume":
                $(".plant_small").attr("src", "media/Sunflower_Bush.png");
                break;
            case "Mohnblume":
                $(".plant_small").attr("src", "media/Poppy_Bush.png");
                break;
        }
        $("#sonne").css({"animation-play-state": "running"});
        $("#text_12").css({"display":"none"});
        $("#text_13").css({"visibility": "visible","display":"block"});
}, 2500);
});
Switch-Anweisung für die Übernahme des Blumenwahl für den weiteren Spielverlauf

Gießkanne

Für die Animation der Gießkanne werden sowohl Keyframe als auch jQuery Animationen verwendet. Bei den keyframes handelt es sich um rein visuelle Effekte, bei der sich die Gestaltung der Gießkanne ändert. Mit Hilfe von bspw. transform:scale() ändert sich ihre Größe, durch opacity ändert sich die Transparenz und durch animation-iteration-count:2 wiederholt sich diese Animation zweimal. Die Bewegung wird anhand von .animate() realisiert, sodass sich die Kanne über die Pflanzen bewegt. Dabei ändert sich mit Hilfe der Anweisung .mousemove ihre Ausrichtung, sobald der User mit der Maus über sie fährt und mit .mouseleave verschwindet die Gießkanne. Gleichzeitig wird auf diese Weise auch die Animation für die Wassertropfen ausgelöst.

/*jQuery-Animation für die Gießkanne und Style Änderungen für Interaktivität*/
$("#giesskanne").click(function() {
    $("#giesskanne").animate({
        bottom: "50%",
        left: "50%",
        }, 4000, "linear", function() {
            /*Animation wird aktiviert nur beim Bewegen auf dem Bild*/
            $("#giesskanne").mousemove(function(evt) {
            $(".wasser_tropfen").css({"display":"block"});
            $("#giesskanne").css({"transform":"rotate(-30deg)"});
            $(".wasser_tropfen").animate({
                bottom: "-55%"
                }, 2500 )
            });
            /*Ausschaltung der Animation*/
            $("#giesskanne").mouseleave(function(evt) {
                $(".wasser_tropfen").css({"display":"none"});
                setTimeout(function () {
                    $("#giesskanne").hide('slow');
                }, 3000);
            });
        });
Animation der Gießkanne

Sonne

Die Sonne bewegt sich im Spiel mit Hilfe von keyframes automatisch über die Blumenwiese bewegt und scheint stärker, sobald der User sie anklickt.

/*Durchgehende Animation für besseres Spiel. Einige Style Egenschaften werden später 
via JS ergänzt*/ 
#sonne {
    position: absolute;
    z-index: 2;
    bottom: 60%;
    left: 70%;
    height: 25%;
    cursor:pointer;
    
    animation-name: sonne_bewegung; 
    animation-duration: 45s;
    animation-timing-function: ease;
    animation-delay: 0s;
    animation-iteration-count: 1;
    animation-fill-mode:forwards;
    animation-play-state: running;
}

@keyframes sonne_bewegung {
    from  { transform: translateX(0px) translateY(0px)}
    to  { transform: translateX(-500px) translateY(-20px)}
}
CSS Anpassungen für die Sonne

Nachdem die Gießkanne eingesetzt wird, stoppt die Bewegungs-Animation der Sonne, damit der User sie leichter anklicken kann. Bei dem Klick auf die Sonne wird sie größer und scheint stärker, um sie hervorzuheben. Das geschieht mit Hilfe der Anweisung 

$("#sonne").click(function() {$("#sonne").css({"height":"30%", "filter":"drop-shadow(0px 5px 25px #FFD700)"});
/*Animation für die Sonne wird aktiviert beim Klick. Für den richtigen
    Spielablauf ist das Anklicken der Sonne nur nach der Animation mit der 
    Gießkanne möglich*/
$("#sonne").click(function() {
    $("#sonne").css({"height":"30%", "filter":"drop-shadow(0px 5px 25px #FFD700)"});
    $(".plant_small").css({"animation-play-state":"running"});
Animation für die Sonne

Magic Booster

Der Magic Booster erscheint mit Hilfe der jQuery Anweisung $(“#booster”).show();. Die Animation wird automatisch ausgelöst, sobald er vom User ausgewählt wurde und läuft mit Hilfe der Anweisung animation-iteration-count: infinite; unendlich in einer Schleife. Durch die Anweisung $(“#booster”).fadeOut(4000); verschwindet der Booster automatisch innerhalb von 4 Sekunden. Auch hier kann man die Zeiteinstellungen nach Belieben und Funktionalität anpassen.

/*Magic Bosster wird angezeigt nur bei "Ja"-Antwort
Animation ist unendlich und startet mit der Erscheinung des Bildes*/

#booster {
    position: absolute;
    z-index: 15;
    height: 150;
    bottom: 70%;
    left: 40%;
    
    animation-name: magic_booster; 
    animation-duration: 3s;
    animation-timing-function: ease;
    animation-delay: 0s;
    animation-iteration-count: infinite;
    animation-fill-mode:backwards;
    animation-play-state: running;
}

/*Animation zeigt den Effekt indem der Booster über die Blumenwiese gegossen wird.*/

@keyframes magic_booster {
    0%  { transform: scale(0.5) rotate(0deg)}
    50%	{ transform: scale(1) rotate(180deg)}
    100%  { transform: scale(0.5) rotate(-180deg)}
    
}
Keyframe Animation für den Magic Booster
/*Bei der Anwendung des Magic Boosters erscheint der animierte 
Booster und fängt an, langsamautomatisch zu verschwinden */
$("#btn_ja").click( function() {
    $(":button").hide();
    $("#booster").show();
    $("#booster").fadeOut(4000);
    setTimeout (function () {
jQuery für den Magic Booster, falls der User “Ja” auswählt

Interaktive Buttons

Sobald die Maus über die Buttons fährt, erscheint ein Hover-Effekt, in dem sich die Farben ändern. Der Hover-Effekt wird durch diese Eigenschaft umgesetzt:

button:hover {

transition: 3s in-back;

background-image: radial-gradient(#ffd700, #ff5433);

}

Außerdem wird der Cursor durch die Eigenschaft cursor:pointer; in Form einer Hand angezeigt, sobald der User mit der Maus über interaktive Elemente fährt. Dadurch weiß er, welche Elemente anklickbar und für den Spielverlauf wichtig sind.

Besonderheiten

Eine Besonderheit der Animation ist die Hintergrundmusik, die während des Spiels läuft. Sie startet automatisch, wenn der User das Spiel beginnt. Beginnt der User ein neues Spiel, indem er auf “Restart” klickt, startet auch die Musik wieder neu. Dies wird mit Hilfe des jQuery-Befehls $(“#background_musik”)[0].play(); umgesetzt. Bei der Hintergrundmusik haben wir darauf geachtet, eine lizenzfreie Musik zu nehmen, die zum Thema die Spiels passt. Dafür haben wir den Titel “The Small Farm” gewählt. Mit dem Befehl $(“#background_musik”)[0].pause(); endet die Musikwiedergabe zum Ende des Spiels automatisch.

Eine weitere Besonderheit ist das Responsive Design. Dieses wird eingesetzt, damit die Animation auf allen Desktopgrößen richtig angezeigt wird und gespielt werden kann. Das Responsive Design wurde mit Hilfe von CSS angepasst und bezieht sich auf alle Elemente im Quellcode. Dies wurde mit der Eigenschaft position: absolute; sowie der Anpassung der Abstände durch bottom: left: right: top: height: in Prozent-Angaben umgesetzt. Die Eigenschaft font-size: 1.05vw; führt dazu, dass auch die Texte optimiert dargestellt werden.


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Entwicklung von Multimediasystemen (Sommersemester 2021, Amy Linh Hoang,  Prof. Dr.-Ing. Steinberg) entstanden. Verwendete Techniken sind HTML5, CSS3 und JavaScript. Die besten Tutorials stellen wir Euch hier in den nächsten Wochen nach und nach vor.

Der Computer für alle

Autor: Nils Dille


Computer waren früher ernsthafte Geräte für ernsthafte Arbeit und demnach auch nicht sehr einfach zu bedienen oder zugänglich.6 Der 1981 erschienen IBM 5150 startete bei einem umgerechneten Preis von ca. 4.400$ und kam dabei nicht mal mit einem Diskettenlaufwerk. Laden und Speichern von Programmen und Daten war so nur über Audiokassetten möglich. Eine sehr langsame und schmerzhafte Erfahrung. Warum man also als Privatperson einen Computer kaufen sollte war fragwürdig. Die rein Textbasierte Interaktion mit dem Gerät schreckte ebenfalls ab und nur technisch versierte Menschen könnten mit einem solchen Gerät etwas anfangen.11

Was ist also mit dem Rest der Menschen?

Ein neuer Weg

1984 kam eine andere Idee des Computers auf dem Markt. Es sollte ein freundliches Haushaltsgerät sein. Leicht zu bedienen und günstig. Dabei aber leistungsfähiger als andere Rechner. Ein Computer der Informationen ausspuckt wie ein Toaster geröstetes Brot.4 Die Rede ist von dem Macintosh von Apple. Der erste erschwingliche Heimcomputer mit grafischer Benutzeroberfläche und einem Zeigegerät namens Maus.

Anstatt Textbefehle einzugeben, konnte man nun einfach auf Ordner und Dateien zeigen, um sie zu öffnen oder zu verschieben. Textdokumente sahen auf dem Bildschirm so aus wie aus dem Ausdruck. Jalousie-Menüs machten die Arbeit einfacher.12 Alles Dinge die man heute von allen Computern kennt. Sie wurden auf dem PC allerdings erst ein Jahrzehnt später zum Standard.7 Der erste Mac war allerdings kein Erfolg. Schlicht zu teuer war er und nicht genug Software war auf dem Markt. 499$ war der Preis den Steve Jobs angedacht hatte. Daraus wurden dann aber 2.495$.12

Besser als ein Notebook, besser als ein Smartphone?

Was ist also aus der Idee des Informationstoasters geworden? Die Welt brauchte wohl noch ein bisschen. Apple probierte es 2010 nochmal mit einer ähnlichen Idee und diesmal mit einem Preis von 499$. Die Rede ist vom iPad. Ein Gerät, das bei seiner Vorstellung im Publikum für Verwirrung gesorgt hat. Die doch sehr zurückhalten Reaktion sind den Zuschauern deutlich anzuhören.2

Von der Presse wird die Daseinsberechtigung eines solchen Gerätes in Frage gestellt. Es sei doch nur ein großes iPhone ohne Telefon und ohne Computer kann man das Ding ja auch nicht einrichten.8 Für wen soll das also gut sein? Das iPad entspricht den ursprünglichen Ambitionen des Macintoshs besser als dieser es jemals konnte. „If you know how to point, you already know how to use it. “, so hieß es in einem Werbespot für den Mac von damals.5 Beim iPad kann man jetzt direkt auf den Bildschirm zeigen und braucht keine Maus mehr.

Tablet Computer Front
Das iPad von vorn
Tablet Computer hinten
Und einmal von hinten. Ganz schön wuchtig aus heutiger Sicht.

Die Idee
Tablet Computer existierten schon lange als Idee in den Köpfen von Sci-Fi Autoren. Eines der ersten Auftritte im Kino hatte das Tablet in Stanly Kubriks 2001: Odyssee im Weltraum aus dem Jahr 1968. Hier wurde ein Tablet verwendet, um einen Videoanruf vom Raumschiff Odyssee zur Erde herzustellen.14 Das iPad hat den Tablet PC nicht erfunden und es gab eine mannigfaltige Auswahl solcher gerate in den 90ern und 2000ern. So auch den Dauphin DTR-1 von 1993. DTR steht hierbei für Desktop-Replacement. Ausgestattet mit Windows 3.1 for Pen Computing und einem Intel 386 Prozessor im inneren stand der Arbeit nichts im Wege. Bis auch das häufig schmelzende Netzteil vielleicht. Das hat mich jedenfalls bisher abgehalten.13 Desktop Arbeitsumgebungen in Tablet Form zu pressen ist wohl ein anderer Grund. Es bedarf einer grundlegen neuen Bedienung, um eine Vernünftige Nutzererfahrung zu schaffen. Und das Internet fehlte damals auch noch.

Meine Erfahrung

Mein Vater kaufte das iPad direkt als es in Deutschland auf den Markt kam. Es übte eine eigenartige Faszination auf mich aus. Das iPad träumte großer als der Macintosh es sich jemals vorstellen konnte. Alles wollte alles sein und das zeigte sich auch. Ein Webbrowser, eine E-Mail-Maschine und Unterhaltungsgerät, aber auch so einige etwas absurdere Einsatzwecke waren angedacht. So kann man vom Sperrbildschirm aus eine Diashow starten und das Gerät zusammen mit dem Dock als digitalen Bilderrahmen verwenden. Mit dem eingebauten Line-Out im Dock kann man sein iPad mit der Stereoanlage verbinden und es so als Musikspieler verwenden. Mit dem AV-Kabel lässt sich das iPad auch an den Fernseher anschließen, um seine Verwandten mit Urlaubsfotos zu langweilen. Importieren kann man die Fotos mithilfe des 30-Pin-Dockconnenctor auf USB oder SD-Karten Adapters. Und wer längere Texte schreiben will, kann einfach eine Bluetooth Tastatur koppeln.

Tablet Computer Bilderrahmen
Der Digitale Bilderrahmen Modus. Wer braucht da noch echte Fotos…

All dieses Zubehör war in üblicher Apple Manier natürlich nicht mitenthalten, aber mein Vater hat sich alles gleich dazu bestellt. Es sollte sein neuer Heimcomputer sein und auch sein einziger. Das ist etwas was sich bis heute nicht geändert hat. Das iPad ist nicht mehr das gleiche, er ist jetzt bei seinem dritten, aber er hat traditionellen Computern den Rücken gekehrt. Größtenteils weil sie teurer und klobiger sind, aber vor allem weil sie schwieriger zu bedienen sind. Das ist etwas was mir schon so manches Mal aufgefallen ist. Wenn ich meine Eltern meinen Laptop vorsetze, um Ihnen etwas zu zeigen, kommt es häufig vor, dass sie den Finger heben und versuchen auf dem Display zu tippen. Das bringt nur Fingerabdrücke auf den Bildschirm, zeigt aber wie natürlich Touch-Bedienung geworden ist.

Der Computer ist tot, lange lebe der Computer!

Mobile Endgeräte machen den größten Teil des Internetverkehres aus. Klassische Computerumgebungen werden mehr und mehr zu einem Nischenmarkt für Entwickler und Professionelle.3, 10 Man hört selten am Esstisch jemanden davon reden, wie er seinen Arbeitsspeicher erweitert hat und nun endlich das neue Betriebssystem installieren kann. Oder wie man die Wärmeleitpaste seiner CPU erneuert hat, um die Temperatur im Betrieb zu senken. Die meisten wollen ein Gerät, das einfach funktioniert und das tut was es soll. Ohne irgendwelche Erweiterungen oder Instandhaltung. Und das ist genau das was Tablets bieten. Man kann und muss sich um nichts kümmern. Das Gerät an sich steht im Hintergrund und der Content im Vordergrund. Das beeinflusst dann auch unseren Umgang mit den Inhalten.

Ein prominentes Beispiel dafür ist der Tod des Flash Players von Adobe. Lange Zeit ein unverzichtbares Werkzeug bei der Erstellung von Webinhalten, ist dieses Jahr endgültig von Adobe eingestellt worden. Ab den 01.02.2021 ist sogar das reine Ausführen des Programms von seitens Adobe blockiert, wenn es noch auf dem Rechner installiert ist.1 Ein Grund für den Untergang von Flash war zu keinem kleinen Teil die sture Verweigerung Flash auf iOS Geräte zu bringen. Steve Jobs hatte seine Gründe damals in einem offenen Brief geäußert.9 Wenn Websites heutzutage keine mobile Version aufweisen, können sie als kaputt und nutzlos betrachtet werden. Ob es einem gefällt oder nicht, wir leben in der Zeit nach dem Computer.

Literaturverzeichnis

1 Abobe (2021): Allgemeine Informationen zur Produkteinstellung von Adobe Flash Player. Zuletzt aktualisiert am 13.01.2021. Online unter https://www.adobe.com/de/products/flashplayer/end-of-life.html [Abruf am 29.01.2021]

2 Ben Hollberg (2010): Introducing iPad. Video publiziert am 29.01.2010 aus YouTube. Online unter https://youtu.be/qxWEpp206lg [Abruf am 30.01.2020]

3 BroadbandSearch (2021): Mobile Vs. Desktop Internet Usage (Latest 2020 Data) Online unter https://www.broadbandsearch.net/blog/mobile-desktop-internet-usage-statistics [Abruf am 28.02.2021]

4 Dernbach, Christoph (o.J.): The History of the Apple Macintosh. Online unter https://www.mac-history.net/top/2020-02-10/the-history-of-the-apple-macintosh [Abruf am 29.01.2021]

5 epicyoutubevideos (2015): Old macintosh ads (1984-85). Video publiziert am 11.08.2015 auf YouTube. Online unter https://youtu.be/JkU3WCSGSw4 [Abruf am 29.01.2021]

6 Hoffman, Cris (2014): PCs Before Windows: What Using MS-DOS Was Actually Like. Zuletzt aktualisiert am 11.05.2014. Online unter https://www.howtogeek.com/188980/pcs-before-windows-what-using-ms-dos-was-actually-like/ [Abruf am 29.01.2021]

7 Long, Tony (2011): Aug. 24, 1995: Say Hello to Windows 95. Zuletzt aktualisiert am 24.08.2014. Online unter https://www.wired.com/2011/08/0824windows-95/ [Abruf am 29.01.2021]

8 Seeger, Andreas (2010): iPad im Test: Keiner braucht das iPad, alle wollen es. Zuletzt aktualisiert am 11.05.2010. Online unter https://www.areamobile.de/iPad-3G-Tablet-273566/Tests/iPad-im-Test-Keiner-braucht-das-iPad-alle-wollen-es-1329423/ [Abruf am 29.01.2021]

9 Shankland, Stephen (2010): Steve Jobs’ letter explaining Apple’s Flash distaste. Apple’s CEO doesn’t like Flash. Here’s the full memo explaining why the company is keeping Adobe Systems’ software off the iPhone and iPad. Zuletzt aktualisiert am 29.04.2010. Online unter https://www.cnet.com/news/steve-jobs-letter-explaining-apples-flash-distaste/ [Abruf am 29.01.2021]

10 StatCounter (o.J.): Operating System Market Share Worldwide – December 2020. Online unter https://gs.statcounter.com/os-market-share [Abruf am 29.01.2021]

11 Steve’s Old Computer Museum (2020a): IBM Personal Computer (PC). Zuletzt aktualisiert am 08.05.2016. Online unter http://oldcomputers.net/ibm5150.html [Abruf am 28.01.2021]

12 Steve’s Old Computer Museum (2020b): Apple Macintosh. Zuletzt aktualisiert am 08.05.2016. Online unter http://oldcomputers.net/macintosh.html [Abruf am 28.01.2021]

13 Steve’s Old Computer Museum (2020a): Dauphin DTR-1. Zuletzt aktualisiert am 08.05.2016. Online unter http://oldcomputers.net/dauphin-dtr-1.html [Abruf am 29.01.2021]

14 Wigley, Samuel (2019): Did Stanley Kubrick invent the iPad?. Zuletzt aktualisiert am 12.05.2019. Online unter https://www2.bfi.org.uk/news-opinion/news-bfi/features/did-stanley-kubrick-invent-ipad [Abruf am 29.01.2021]


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Content Management (Wintersemester 2020/21, Prof. Dr.-Ing. Steinberg) entstanden.

Die besten Beiträge stellen wir Euch hier in den nächsten Wochen nach und nach vor.

Smart Libraries: Wie smart müssen Bibliotheken sein?

Beitragsbild Smart Libraries – Wie smart müssen Bibliotheken sein?

 

Bibliotheken sind weit mehr als reine Aufbewahrungsorte für Medien aller Art. In diesem Beitrag zeigen wir, inwieweit sich Bibliotheken im Sinne von Smart Libraries weiterentwickelt haben und welchen Nutzen Kund*innen davon haben.

Struktur des Beitrages:

Was ist Smart?

Der deutsche Duden führt für das Wort „Smart“ die Begriffe gewitzt und clever.[4] So wird das Wort “Smart” derzeit viel im Zusammenhang mit intelligenten und computergesteuerten Systemen benutzt. Es bestehen bereits sowohl Wörter wie Smarte Technologien als auch Smartphones, Smart Homes und Smart Cities. Doch unter Smart Libraries kann sich kaum jemand etwas vorstellen.

Um eine Vorstellung von einer Smart Library zu bekommen, schauen wir uns zuerst ein Modell von einer Smart City an:

Smart City Wheel

Boyd Cohen beschäftigt sich mit den Themen nachhaltige und intelligente Entwicklung von Städten und ist der Begründer des Smart City Wheel. Laut Cohen gliedert sich eine smarte Stadt in sechs Themenfelder: Mobilität, Bevölkerung, Umwelt, Regierung, Wirtschaft und Lebensraum.

Eine intelligente, smarte Mobilität legt den Schwerpunkt darauf, den Verkehr in den Städten billiger, schneller und umweltfreundlicher zu machen. Die Ziele sind zum einen die Steigerung der Effizienz und eine Verbesserung des Verkehres, der durch die Stadt führt und zum anderen wird gezielt in eine innovative Verkehrspolitik investiert. Folglich müssen neue Verkehrsträger gewonnen werden. Desweiteren muss der Personen- und Warentransport gefördert und die Belastung der Umwelt reduziert werden.

Für eine smarte Bevölkerung stehen die Auswahl des Berufes, die Chancen auf dem Arbeitsmarkt, die Berufsausbildung und auch lebenslanges Lernen für alle Altersgruppen im Vordergrund. Abgesehen davon sind sind wichtige Punkte die Integration, die persönliche Weiterentwicklung, die Steigerung des Wohlstands und die Stärkung der Gemeinschaft.

Das Thema smarte Umwelt beschäftigt sich mit einer grünen und umweltbewussten Stadt. Wichtige Punkte sind hierbei die Reduzierung der CO2-Emissionen, die Reduzierung von Müll und die Verwendung von erneuerbaren Energien. Die Regierung in einer smarten City setzt sich für die Zusammenarbeit und Interaktionen zwischen den Bürgern, den Unternehmen und der Verwaltung ein.

Das Ziel einer smarten Wirtschaft ist das innovative und nachhaltige Wachstum der Wirtschaft in einer Stadt. Die Attraktivität einer Stadt muss gesteigert werden, um neue Unternehmen, Geschäfte und Investoren dazu zu gewinnen und dadurch wiederum neue Arbeitsplätze zu schaffen. Ein smarter Lebensraum bietet den Menschen ein gut ausgebautes Gesundheitssystem und die Einbindung von allen Alters- und Bevölkerungsgruppen. Neue Technologien ermöglichen Sicherheit. Ein weiterer Aspekt ist ein breites Freizeit- und Kulturangebot zur Selbstverwirklichung und Stärkung der sozialen Kontakte.[1]

Quelle: Smart City Wheel · Projects · Smart City Hub

Wie finden Bibliotheken nun ihren Platz in einer Smart City und werden Smart Libraries? In ihrem Buch „Smart Libraries. Konzepte, Methoden und Strategien“ stellen die beiden Herausgeberinnen Linda Freyberg und Sabine Wolf eine Smart Map für Bibliotheken vor und geben Bibliotheken, die smarter werden möchten, neue Ideen mit auf den Weg. [8]

Smart Libraries – Wie sieht’s in der Praxis aus?

Die Umsetzungen von neuen, smarten Ideen sind von Bibliothek zu Bibliothek unterschiedlich. Einige Bibliotheken setzen den Fokus auf Nachhaltigkeit, die durch neue Technik erreicht werden kann. Die Universität Hildesheim ist mit ihrer Smart Library bereits 2012 gestartet. Das Energiemanagement der Universitätsbibliothek wird mit einem “Smart-Home-System” gesteuert. Dieses System beinhaltet zum Beispiel Sensoren, die den Lichteinfall in einem Raum registrieren und den Beleuchtungsbedarf selbständig regeln. [7]

Auch die Bibliothek der technischen Universität (DTU) in Dänemark zeigt in dem folgenden Video, wie eine Smart Library aussehen kann:

In dem Video wird gezeigt, wie in der Bibliothek neue Technik eingesetzt wird. Sensoren gestalten die Arbeitsumgebung für die Student*innen, indem die Raumwärme oder die Beleuchtung der Anzahl der Personen im Raum angepasst wird. Eine App hilft den Student*innen das gesuchten Buch in dem Regal zu finden. Zusammen gefasst versteht sich die DTU als eine Umgebung, in der neue Technologien ausprobiert werden können.[3]

Die Teilhabe von Kunden*innen und das selbstständige Arbeiten wollen Makerspaces in Bibliotheken fördern. Ein Beispiel ist die Hoeb4U der Bücherhallen Hamburg oder der Makerspace der Sächsischen Landesbibliothek – Staats- und Universitätsbibliothek Dresden. In der Hoeb4U können nicht nur ein Häkelset oder Bastelmaterialien ausgeliehen werden, sondern es finden auch Veranstaltungen vor Ort statt.[2] In Dresden liegt der Fokus auf Technik, so kann ein 3D- Drucker oder eine Kamera ausgeliehen und vor Ort ausprobiert werden. Zugleich bekommen Nutzer*innen von Fachpersonal oder anderen Nutzer*innen Hilfe bei der Benutzung der Makerspaces.[6]

Fazit

Bibliotheken entwickeln sich ständig weiter und haben dabei die Bedürfnisse der Kund*innen fest im Blick. Der Anspruch an eine Bibliothek hat sich gewandelt. Einerseits möchten Kund*innen das Medienangebot einer Bibliothek nutzen, andererseits auch das Angebot an Veranstaltungen wahrnehmen und sich mit anderen Kund*innen austauschen und treffen. Die Kennzeichen einer Smart City spielen dabei eine wichtige Rolle: gemeinsam genutzte Räume senken die CO2 Emission und es findet ein Austausch zwischen unterschiedlichen Gruppen der Bevölkerung statt. Kund*innen haben die Möglichkeit sich aktiv einzubringen und durch niedrigschwellige Angebote werden Teilhabe und Inklusion gefördert.

Letztendlich stellt sich die Frage: Ist eine Bibliothek nicht von Anfang bereits eine Smart Library? Im Laufe ihrer Geschichte musste sie sich immer wieder an die Bedürfnisse ihrer Kund*innen anpassen und sich verändern – lange bevor das Wort Smart in Mode kam.

Verwendete Quellen

1bee smart city (2020): smart city indicators. Online unter https://hub.beesmart.city/en/smart-city-indicators [Abruf am 18.01.2021]

2Büchrhallen Hamburg (2021): Jugendbibliothek Hoeb4U.Konzept. Online unter: https://www.buecherhallen.de/hoeb4u-konzept.html [Abruf am 15.01.2021]

3DTUdk(2018):DTU Smart Library-What is it? [Video]. Online unter: https://www.youtube.com/watch?v=qEc7_8xpdj4 [Abruf am 15.01.2021]

4Duden (2020): Wörterbuch. Online unter https://www.duden.de/rechtschreibung/smart [Abruf am 15.01.2021]

5Smart City Hub Switzerland (o. J.): Smart City Wheel. Online unter https://www.smartcityhub.ch/smart_city_wheel.120en.html [Abruf am 18.01.2021]

6SLUB Dresden (2021): SLUB Makerspace. Online unter https://www.slub-dresden.de/mitmachen/slub-makerspace/ [Abruf am 18.01.2021]

7Universität Hildesheim (2012): “Smart Library” – Energieverbrauch senken durch intelligente Steuerungssysteme. Ein Vorhaben im Rahmen der “Sustainable University Hildesheim. Zuletzt aktualisiert am 25.08.2020. Online unter https://www.uni-hildesheim.de/bibliothek/smart-library/. [Abruf am 14.01.2021]

8Wolf, Sabine (2019): Definition einer Smart Library und Erläuterung der Smart Map. Ein State -of-the-Art Ansatz. In: Freyberg, Linda; Wolf, Sabine (Hg.): Smart Libraries. Konzepte,Methoden und Strategien. Wiesbaden: b.i.t. Verlag gmbh (b.i.t. online innovativ, Bd. 76), S. 21-26


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Content Management (Wintersemester 2020/21, Prof. Dr.-Ing. Steinberg) entstanden. Die besten Beiträge stellen wir Euch hier in den nächsten Wochen nach und nach vor.

Forty in 49: Ein Spiel für Gedächtnis und räumliches Vorstellungsvermögen

Beitragsbild forty in 49 - ein Spiel für das Gedächtnis und das räumliche Vorstellungsvermögen

Autor: Jannis Fortmann

Link zum Spiel
Zip Datei zum Download

Inhalt

Konzept

Von Anfang an war es mein Plan, ein simples und optisch ansprechendes kleines Spiel zu designen, bei dem Animationen sinnvoll zum Einsatz kommen.

Nach ein paar verworfenen Ideen entschied ich mich für diese Variante, bei der die räumliche Wahrnehmung und das Gedächtnis des Spielers auf die Probe gestellt wird. Das Konzept des Spiels ist angelehnt an einen Intelligenztest für Schimpansen, bei dem deren Arbeitsgedächtnis getestet wird. Bei diesem werden aufeinanderfolgende Zahlen auf einem Bildschirm abgebildet, diese zahlen müssen dann in der richtigen Reihenfolge gedrückt werden. Nachdem die erste Zahl gedrückt wurde, werden alle anderen hinter identisch aussehenden Feldern versteckt.

Mein Spiel „forty in 49“ funktioniert nach einem ähnlichen Prinzip. Anstatt einer bestimmten Reihenfolge geht es hierbei aber um die Position der Felder. In einem Raster sind 7×7 Felder angeordnet,. Zu Beginn des Spiels verschwinden 40 der 49 Felder für wenige Sekunden. Der Spieler muss sich die Position der übrigen 9 Felder (Bomben) merken und diese vermeiden. Das Ziel ist es, möglichst viele der 40 Felder anzuklicken. Klickt man auf eine Bombe, ist das Spiel vorbei.

Animationen

Die Animationen erfüllen sowohl funktionale als visuelle Zwecke.

Um die Orientierung zu vereinfachen, werden Felder größer und ändern ihre Farbe, wenn der Mauszeiger darüber hovert. Wird ein Feld angeklickt, wird es entweder grün und verschwindet in einer rotierenden Animation, oder es wird rot und dreht sich langsam um 180° um die y-Achse und um 45° um die z-Achse. Dadurch wird dem Spieler visuell verdeutlicht, ob er richtig lag. Um das Ganze auditiv zu unterstützen, gibt es für den Klick auf die zwei Arten von Feldern jeweils einen Soundeffekt.

Ist das Spiel vorbei (alle richtigen Felder oder eine Bombe wurden geklickt), erscheint eine Karte mit der Punktzahl. Sie bewegt sich von unten nach oben und landet mittig über dem Spielfeld. Außerdem gibt es natürlich die fade-out/fade-in Animation am Anfang, ohne die das Spiel überhaupt nicht möglich wäre.

Technische Umsetzung

Die Seite wurde mithilfe von HTML, CSS und JavaScript erstellt.

HTML

In der HTML-Datei wird der Aufbau der Seite bestimmt. Alle nicht-dynamischen Inhalte werden definiert und mithilfe von DIV-Containern positioniert.

In dem DIV „wrap“ befinden sich alle anderen Objekte, es definiert den Abstand zu den Seitenrändern. Unter der Überschrift und einer kurzen Spielbeschreibung befindet sich der Start-Button und darunter der aktuelle Punktestand.

Das Spielfeld besteht aus 49 einzelnen DIVs für die kleinen, quadratischen Felder. Diese sind umschlossen von dem DIV „grid“, welches sich innerhalb des DIV „background“ befindet.

Darunter befinden sich die DIVs „gameOver“ und „finalScore“ sowie der Restart-Button. Diese Elemente bestimmen die Karte, die zum Ende des Spiels erscheint, bis dahin sind sie unsichtbar.

Jedem der 49 Spielfeld-DIVs werden drei Klassen zugeordnet. Alle bekommen die Klasse „cell“, über die alle Felder auf einmal angesprochen werden können. Außerdem bekommt jedes Feld eine individuelle Klasse (c1 bis c49) und entweder die Klasse „bomb“ oder „noBomb“. Damit können die beiden Arten von Feldern getrennt voneinander bearbeitet werden.

<!DOCTYPE html>
<html lang="en" >
  <head>
    <meta charset="UTF-8">
    <title>forty in 49</title>
    <link rel="stylesheet" href="./style.css">
  </head>
  <body>
    <div class="wrap">
      <h1>
        forty in 49
      </h1>
      <p>
        a simple game<br>
        49 tiles - 40 are good 9 are bad<br>
        press start to see the bad ones<br>
        click on all the good ones
      </p>
      <button id="start">
        start
      </button>
      <div id="score">
        score: 0
      </div>
      <div class="background">
      </div>
      <div class="gameOver">
        your final sccore is: 
        <div id="finalScore">
          0
        </div>
        <button id="restart">
          restart
        </button>
      </div>
    </div>
    <script  src="./script.js">
    </script>
  </body>
</html>
<div class="background">
   <div class="grid">
     <div class="cell c1 noBomb"></div>
     <div class="cell c2 bomb"></div>
     <div class="cell c3 noBomb"></div>
     <div class="cell c4 noBomb"></div>
     <div class="cell c5 noBomb"></div>
     <div class="cell c6 noBomb"></div>
     <div class="cell c7 noBomb"></div>
     <div class="cell c8 noBomb"></div>
     <div class="cell c9 noBomb"></div>
     <div class="cell c10 noBomb"></div>
     <div class="cell c11 bomb"></div>
     <div class="cell c12 noBomb"></div>
     <div class="cell c13 bomb"></div>
     <div class="cell c14 noBomb"></div>
     <div class="cell c15 noBomb"></div>
     <div class="cell c16 noBomb"></div>
     <div class="cell c17 noBomb"></div>
     <div class="cell c18 noBomb"></div>
     <div class="cell c19 noBomb"></div>
     <div class="cell c20 noBomb"></div>
     <div class="cell c21 noBomb"></div>
     <div class="cell c22 noBomb"></div>
     <div class="cell c23 noBomb"></div>
     <div class="cell c24 bomb"></div>
     <div class="cell c25 noBomb"></div>
     <div class="cell c26 bomb"></div>
     <div class="cell c27 noBomb"></div>
     <div class="cell c28 noBomb"></div>
     <div class="cell c29 bomb"></div>
     <div class="cell c30 noBomb"></div>
     <div class="cell c31 noBomb"></div>
     <div class="cell c32 noBomb"></div>
     <div class="cell c33 noBomb"></div>
     <div class="cell c34 bomb"></div>
     <div class="cell c35 noBomb"></div>
     <div class="cell c36 noBomb"></div>
     <div class="cell c37 bomb"></div>
     <div class="cell c38 noBomb"></div>
     <div class="cell c39 noBomb"></div>
     <div class="cell c40 noBomb"></div>
     <div class="cell c41 noBomb"></div>
     <div class="cell c42 noBomb"></div>
     <div class="cell c43 noBomb"></div>
     <div class="cell c44 noBomb"></div>
     <div class="cell c45 noBomb"></div>
     <div class="cell c46 bomb"></div>
     <div class="cell c47 noBomb"></div>
     <div class="cell c48 noBomb"></div>
     <div class="cell c49 noBomb"></div>
   </div>
 </div>

CSS

In CSS wird das optische Erscheinungsbild der Seite bestimmt.

Die Hintergrundfarbe und Stil der Schrift werden definiert.

body {
  background-color: #4d4d4d;
  color: #b488b8;
  font-family: Calibri;
  text-align: center;
  text-transform: uppercase;
}

h1 {
  font-size: 60px;
}

Die Buttons werden abgerundet und bekommen jeweils eine Hintergrundfarbe.

#start {
  color: #b488b8;
  background-color: #fff;
  font-family: Arial;
  font-size: 24px;
  text-transform: uppercase;
  border: none;
  border-radius: 5px;
  padding: 10px;
  margin: 20px;
}

#restart {
  display: none;
  color: #b488b8;
  background-color: #4d4d4d;
  font-family: Arial;
  font-size: 24px;
  text-transform: uppercase;
  border: none;
  border-radius: 5px;
  padding: 10px;
  margin: 20px;
}

Der Bereich unter dem Spielfeld wird abgerundet und bekommt eine andere Farbe.

.background {
  position: relative;
  box-sizing: border-box;
  float: left;
  background-color: #ababab;
  width: 100%;
  border-radius: 10px;
  padding-bottom: 5%;
  margin-top: 30px;
}

Die Spielfelder werden zu abgerundeten Quadraten und bekommen einen Rand und eine Farbe.

.cell {
  box-sizing: border-box;
  -moz-box-sizing: border-box;
  -webkit-box-sizing: border-box;
  float: left;
  width: 14.28%;
  padding-bottom: 13.8%;
  border: 1px solid white;
  background-color: #1e1e1e;
  border-radius: 5px;
}

Die Karte, die nach Beendung des Spiels erscheint, wird im gleichen Stil designt.

.gameOver {
  opacity: 0;
  box-sizing: border-box;
  float: left;
  background-color: #fff;
  width: 94%;
  padding: 5%;
  margin: 3%;
  border-radius: 10px;
  transition: transform 1s cubic-bezier(0.38, 0.4, 0, 1.18);
  transition-delay: 3s;
}

Auch die Animationen werden in CSS erzeugt.

Beim Klick auf den Start-Button werden alle Felder, die keine Bomben sind, für wenige Sekunden langsam durchsichtig und dann wieder sichtbar.

/* fade-out fade-in der nicht-Bomben beim Klick des Start-Buttons (keyframe fade) */
.noBomb.start {
  animation: fade 7s;
}
@keyframes fade {
  0% {
    opacity: 1;
  }
  50% {
    opacity: 0;
  }
  100% {
    opacity: 1;
  }
}

Beim hovern über einen der Buttons wird dieser um 10% größer.

#start:hover,
#restart:hover {
  transition: transform;
  transform: scale(1.1);
}

Die Farbe der der einzelnen Felder ändert sich beim hovern und sie wachsen langsam um 30%.

.cell:hover {
  transition: background-color, transform 0.5s;
  background-color: #b488b8;
  transform: scale(1.3);
}

Wird ein Feld angeklickt, das keine Bombe ist, wird es grün und in einer rotierenden Bewegung kleiner, bis es verschwunden ist.

/* Animation der nicht-Bomben nach Klick */
.noBomb.clicked {
  transition: background-color, transform 4s;
  background-color: #81c7a2 !important;
  transform: scale(0) rotate(720deg);
  pointer-events: none;   /* verhindert, dass ein Feld mehrfach geklickt werden kann */
}

Beim Klick auf eine Bombe wird diese rot und dreht sich um die y- und die z-Achse.

/* Animation der Bomben nach Klick */
.bomb.clicked {
  transition: background-color, transform 4s;
  background-color: #ff695e !important;
  transform: rotateY(180deg) rotateZ(45deg);
  pointer-events: none;
}

Nach Beendung des Spiels erscheint die Karte mit dem Punktestand, verliert langsam ihre Durchsichtbarkeit und wandert von unten nach oben, bis sie über der Mitte des Spielfelds landet.

JavaScript

JavaScript ist zuständig für die Funktionalität der Seite. Hier wird unter anderem definiert, was genau passiert, wenn ein bestimmtes Objekt angeklickt wird. Dabei wird dem Objekt eine neue Klasse zugeordnet, was die in CSS bestimmte Animation auslöst.

Beim Klick auf den Start-Button werden alle Objekte der Klasse „noBomb“ ausgewählt. Mithilfe einer For-Schleife wird ihnen die Klasse „start“ zugeordnet, was die in CSS definierte Animation auslöst.

// fade-out / fad-in bei Klick auf den Start-Button
let start = document.querySelector("#start");
let noBomb = document.querySelectorAll(".noBomb");
start.addEventListener("click", () => {
  for (var i = 0; i < noBomb.length; i++) {
    noBomb[i].classList.add("start");
  }
});

Ein Klick auf den Restart-Button sorgt dafür, dass die Seite neu geladen wird.

// neu laden der Seite bei Klick  auf Restart-Button
let restart = document.querySelector("#restart");
restart.addEventListener("click", () => {
  window.location.href = window.location.href;
});

Beim Klick auf eins der normalen Felder wird dem Objekt die Klasse „clicked“ zugeordnet und dadurch die CSS-Animation ausgelöst. Zusätzlich wird ein Soundeffekt abgespielt. Außerdem wird der Punktestand um 1 erhöht und überprüft, ob dadurch die maximale Punktzahl erreicht wurde. Falls dass der Fall ist, wird die Spielabschlusskarte gezeigt und animiert.

// Animation der nicht-Bomben und counter der Punktzahl
let c1 = document.querySelector(".c1");
c1.addEventListener("click", () => {
  c1.classList.add("clicked");
  count += 1;
  score.innerHTML = "score: " + count;
  finalScore.innerHTML = count;
  if (count == 40) {
    restart.classList.add("true");
    for (var i = 0; i < cell.length; i++) {
      cell[i].classList.add("over");
    }
    gameOver.classList.add("true");
  }
  audioNoBomb.play();
});

Der Klick auf eine der Bomben funktioniert ähnlich, auch hier wird die Animation ausgelöst. Außerdem wird allen Feldern die Klasse „over“ zugeordnet, was dafür sorgt, dass keine weiteren Felder angeklickt werden können.

// Animation der Bomben und der Karte nach Beendung des Spiels
let c2 = document.querySelector(".c2");
let cell = document.querySelectorAll(".cell");
c2.addEventListener("click", () => {
  finalScore.innerHTML = count;
  c2.classList.add("clicked");
  restart.classList.add("true");
  for (var i = 0; i < cell.length; i++) {
    cell[i].classList.add("over");
  }
  gameOver.classList.add("true");
  audioBomb.play();
});

Auch die Audiodateien werden über JavaScript eingebettet.


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Entwicklung von Multimediasystemen (Sommersemester 2021, Amy Linh Hoang,  Prof. Dr.-Ing. Steinberg) entstanden. Verwendete Techniken sind HTML5, CSS3 und JavaScript. Die besten Tutorials stellen wir Euch hier in den nächsten Wochen nach und nach vor.

Design Thinking: Volle Kreativität voraus

Beitragsbild Design Thinking

Oder: It’s not about the design, it’s about the thinking!

Autorin: Katharina Kroupa 


„Man kann über Design Thinking noch so viel Positives erzählen, die Arbeitsweise und ihre Wirkung erklären: Um sie wirklich zu verstehen, muss man sie selber hautnah miterlebt haben.“

 Marcel Plaum, VP Terminal Development Fraport

Na, macht dich das neugierig zu erfahren, was Design Thinking ist? Du hast den Begriff nun schon öfter gehört, aber noch keine Idee, was dahinter alles steckt?

Dann bist du hier genau richtig! Ich bringe dir in diesem Beitrag die Innovationsmethode Design Thinking näher. Was dich alles erwartet im Überblick:

 

Grundsätze des Design Thinkings

Stell dir vor, du arbeitest – sagen wir mal – in einer großen Bibliothek. Ihr stellt Nutzer:innen Medien zur Verfügung, bietet diverse Dienstleistungen an und außerdem kann man bei euch auch vor Ort arbeiten. Eure Bibliothek wird als Lernort grundsätzlich gern genutzt, aber ihr merkt, dass es Verbesserungspotenzial gibt. Euer Gebäude ist schon älter, ebenso die Einrichtung und ihr möchtet den Lernraum für eure Nutzer:innen attraktiver gestalten. Und so bildet sich ein Team aus Mitarbeiter:innen, die sich beratschlagen, was einen modernen Lernraum ausmacht. Eine Kollegin schlägt vor, weitere Computer zur Nutzung anzuschaffen, ein anderer ist der Meinung, dass voll ausgestattete Gruppenarbeitsräume her müssen. Und so suchen Bibliotheksmitarbeiter:innen untereinander nach geeigneten Lösungen.

Doch wofür eigentlich? – Na für ein neues Raumkonzept! – Okay…

Aber für wen eigentlich? – Na für die ganzen Benutzer:innen der Bibliothek!

– Ahaaa..! Aber wäre es da nicht sinnvoll, diese Personen erstmal nach ihrer Meinung zu fragen und sie miteinzubeziehen, wenn man doch für genau diese eine Lösung sucht?

Und damit sind wir beim ersten Grundsatz der Design Thinking Methode, der in jeder Phase des Innovationsprozesses zentral ist: Der Mensch als Inspirationsquelle.

Der Gedanke des Design Thinking ist, dass ein Produkt oder eine Dienstleistung dann richtig gut werden kann, wenn die Bedürfnisse der Zielgruppe richtig ermittelt und bedient werden. Dazu wird diese Zielgruppe aktiv in den Innovationsprozess miteingezogen.[1] Wie das geschieht, erfährst du in weiter unten im Beitrag.

Ein weiterer Grundsatz der Methode ist das Bilden und Zusammenarbeiten innerhalb multidisziplärer Teams. Die Idee hierhinter ist, dass Menschen verschiedener Disziplinen bzw. Fachrichtungen, ihre unterschiedlichen Erfahrungen in den Ideenprozess einbringen und so gemeinsam eine (bessere) Lösung für das Problem finden können. Diversität in Geschlecht, Alter, Fachrichtung ist hier zielführend. Meist bestehen diese Teams aus 4-6 Teilnehmer:innen, den sogenannten Design Thinkers. Noch unerfahrene Teams werden dazu von ein bis zwei Moderator:innen beim Prozess unterstützt.[2]

Die einzelnen Mitglieder multidisziplinärer Teams entwickeln gemeinsam Ideen.
Quelle: giphy

Da bei diesem Zusammenspiel unterschiedlicher Personen schnell das Ziel – nämlich das Finden einer zielgruppenorientierten Lösung – aus den Augen verloren werden kann, ist es wichtig, dabei einem strukturierten Prozess zu folgen.[3] Das bringt uns zum nächsten Inhaltspunkt dieses Beitrags.

Wie läuft der Prozess der Methode ab?

Der Prozess des Design Thinking besteht aus aufeinander folgenden Phasen. Die Phasen bauen aufeinander auf. Erst, wenn eine Phase abgeschlossen ist, kann mit den dabei entstandenen Ergebnissen in der nächsten Phase weitergearbeitet werden.

In allen Phasen ist die Zielgruppe im Fokus. Innerhalb der ersten drei Phasen (Verstehen, Beobachten, Point of View) empathisiert das Team mit der Zielgruppe. Es versucht das zentrale Problem zu verstehen und zu definieren. In den darauffolgenden Phasen (Ideation, Prototyping, Testen) werden Ideen zur Problemlösung gesammelt und konkretisiert. Prototypen werden erstellt und aus Nutzersicht oder von tatsächlichen Nutzer:innen getestet.

Klicke auf die Info-Buttons der verschiedenen Phasen, um Einzelheiten zu erfahren:

Im besten Fall wird dieser Prozess einmal vom Anfang bis zur Entscheidung durchlaufen. Fallen den Testnutzer:innen in der Testphase allerdings Schwachstellen auf oder sie sind in sonst einer Weise nicht zufrieden mit der Lösung, müssen vorherige Phasen wiederholt werden. Beispielsweise werden in der Ideation-Phase dann noch einmal diverse Ideen gesammelt. Daraus werden dann wieder vereinzelte Lösungsansätze ausgewählt, sodass aus diesen nachfolgend ein Protoyp entwickelt wird. Oder die testende Zielgruppe fühlt sich insgesamt noch nicht ausreichend verstanden. Dann beginnt der Prozess erneut beim Verstehen.[4]

Das wird so lange wiederholt bis sich das Team Schritt für Schritt der idealen Lösung angenähert hat. Diesen Vorgang nennt man Iteration. Demnach wird der Prozess des Design Thinking auch als iterativer Prozess bezeichnet.[5]

Welche Voraussetzungen und Tools unterstützen den Innovationsprozess?

Aus dem vorherigen Abschnitt kennst du nun die einzelnen Phasen des Design Thinking Prozesses. Aber wie oder wodurch kann dieser Prozess unterstützt werden? Und wie fördert man die Kreativität am besten?

Die folgenden Abschnitte geben Einblick über die Voraussetzungen für einen gelungenen Innovationsprozess sowie Beispiele für nutzbare Tools zur Kreativitätsförderung[6]:

Wieso sich Design Thinking in jedem Lebensbereich lohnt

Die Methode findet Anwendung in verschiedenen Bereichen und zu verschiedenen Themen. Beispielhaft werden nachfolgend ihr Nutzen und ihre Anwendbarkeit in einer Tabelle dargstellt:

Nutzen Anwendbarkeit
nachhaltige Teamentwicklung Aufbau von Kundenverständnis
effizientere Innovationsprozesse durch schnelles Feedback Gestaltung neuer Produkte und Dienstleistungen
Kundenloyalität steigern durch Integration Optimierung von Organisationsprozessen
geringe Kosten Erstellen von Marketingkampagnen
Tabelle: Nutzen und Anwendbarkeit von Design Thinking

Als Innovationsmethode definiert sich Design Thinking unter anderem über seine Anwender:innen. Da diese und ihre Probleme sehr unterschiedlich sein können, eignet sie sich für das Finden von Lösung in jedem Lebens(Problem-)bereich.

Wie Bosch Design Thinking für User Experience nutzt

Auch bekannte Firmen nutzen mittlerweile die Design Thinking Technik zur Lösung verschiedenster Probleme oder zur Entwicklung neuer Produkte.

Eine davon ist Bosch. Das Unternehmen nutzt die Technik für eine enge Zusammenarbeit mit ihrer Zielgruppe. Im nachfolgenden Video geben Bosch-Mitarbeiter Einblick darin, wie die Methode in der Firma umgesetzt wird.

Youtube-Video: Design-Thinking bei Bosch – Zwischen Post-Its, Lego und Fritz-Kola[7]

FazitIts’s not about the design

it’s about the thinking!

Die Angst vor Fehlern bringt Menschen dazu, die Risiken im Fokus zu haben – nicht die Möglichkeiten!

Aber aus Fehlern lernt man. Design Thinking gibt den Raum für diese offene Denkweise in einem geführten Prozess. Jeder Prozess-Teil führt zu klaren Ergebnissen, mit denen der nächste Prozess-Schritt beginnt.

Obwohl jede Design Thinking Aktivität darauf ausgerichtet ist, die Erfahrungen der Mitmenschen zu verstehen, verändert sie auch die Erfahrungen und Denkweisen der Innovatoren.


Quellen:

DGO (2017): Der Design Thinking Prozess. In 6 Schritten zum Produkt. Online unter: https://blog.dgq.de/der-design-thinking-prozess-in-6-schritten-zum-produkt/ [Abruf am 31.01.2021]

FAZ (2018): Design-Thinking bei Bosch: Zwischen Post-Its, Lego und Fritz-Kola. Youtube. Online unter: https://www.youtube.com/watch?v=F184mC8K2HI&feature=youtu.be

Kreutzer, Ralf T. (2018): Toolbox für Marketing und Management. Kreativkonzepte, Analysewerkzeuge, Prognoseinstrumente. Berlin: Springer. DOI: doi.org/10.1007/978-3-658-21881-2

Plattner, H.; Meinel, C. u. Weinberg, U. (2009): Design Thinking. Innovation lernen, Ideenwelten öffnen. München: mi.

Schallmo, Daniel (2017): Design Thinking erfolgreich anwenden. So entwickeln Sie in 7 Phasen kundenorientierte Produkte und Dienstleistungen. Wiesbaden: Springer Gabler. DOI: doi.org/10.1007/978-3-658-12523-3


Dieser Beitrag ist im Studiengang Informationsmanagement an der Hochschule Hannover im Rahmen des Kurses Content Management (Wintersemester 2020/21, Prof. Dr.-Ing. Steinberg) entstanden. Die besten Beiträge stellen wir Euch hier in den nächsten Wochen nach und nach vor.