Kooperativer Bibliotheksverbund

UID:

Format: 1 online resource (348 pages)

Edition: 1st ed.

ISBN: 9783631868065

Series Statement: Inquiries in Language Learning Series ; v.29

Content: Der Umgang mit Mehrsprachigkeit in der Primarstufe erfordert spezifisches Professionswissen. Lehramtsstudierende können dieses bereits zu Beginn des Studiums erwerben. Sie formulieren nach einer Intervention sehr zielführende Handlungsentscheidungen und -begründungen für in Textvignetten dargestellte Problemsituationen.

Note: Cover -- Series Information -- Copyright Information -- Vorwort -- Preface -- Dedication -- Inhaltsverzeichnis -- Tabellenverzeichnis . -- Abbildungsverzeichnis -- 1 Einleitung -- 1.1 Einordnung der Thematik -- 1.2 Aufbau -- 2 Lehrer(bildungs)forschung -- 2.1 Der Expertenansatz -- 2.2 Der Kompetenzbegriff in der Lehrerbildung -- 2.3 Erfassung professioneller Kompetenz von Lehrpersonen -- 2.4 Systematisierung von professioneller Kompetenz von Lehrpersonen -- 2.4.1 Standardmodelle -- 2.4.2 Kompetenzmodelle -- 2.4.3 Zusammenfassung: Standard- und Kompetenzmodelle -- 2.5 Das professionelle Wissen von Lehrpersonen -- 2.5.1 Strukturierung in Inhaltsgebiete -- 2.5.2 Strukturierung in Wissensformen -- 2.5.3 Empirische Befunde zum professionellen Wissen (angehender) Lehrpersonen -- 3 Mehrsprachigkeit und Schule -- 3.1 Lehren und Lernen in mehrsprachigen Klassen -- 3.2 Mehrsprachig im einsprachigen Unterricht -- 3.3 Forschung zur schulischen Mehrsprachigkeit -- 3.3.1 Individuelle mehrsprachige Entwicklung -- 3.3.2 Schulische Förderung von Mehrsprachigkeit -- 3.4 Gesamtsprachendidaktik - ein Modell für die Primarstufe -- 3.4.1 Förderung von Language Awareness -- 3.4.2 Förderung der Bildungssprache Deutsch (als Zweitsprache) - sprachsensibler Unterricht -- 3.4.3 Cross-Curricular Language Learning im frühen Englischunterricht -- 3.4.4 Die Förderung von transkultureller kommunikativer Kompetenz -- 3.5 Lehrerbildung im Kontext von Mehrsprachigkeit -- 4 Beschreibung der Lehrveranstaltung/Intervention -- 4.1 Strukturelle Merkmale -- 4.2 Inhalte und methodisch-didaktisches Vorgehen -- 4.2.1 Einführung: Mehrsprachigkeit mit Englisch -- 4.2.2 Themenfeld I: Sprache(n) und Identitäte(n), Sprachenpolitik -- 4.2.3 Themenfeld II: Sprachenlernen - Sprachenunterricht -- 4.2.4 Themenfeld III: Gesamtsprachliche Förderung -- 5 Forschungsfragen -- 6 Forschungsdesign. , 6.1 Forschungsansatz -- Interventionsforschung und Evaluationsforschung -- 6.2 Untersuchungsplan -- 6.3 Durchführung -- 6.4 Stichprobenbeschreibung -- 6.5 Forschungsinstrument Fallvignette -- 6.5.1 Entwicklung des Textvignetten-Tests -- 6.5.2 Auswertung des Textvignetten-Tests -- 6.6 Qualitative Inhaltsanalyse -- 6.6.1 Grundbegriffe der qualitativen Inhaltsanalyse -- 6.6.2 Merkmale der inhaltlich strukturierenden qualitativen Inhaltsanalyse -- 6.6.3 Merkmale der evaluativen qualitativen Inhaltsanalyse -- 6.7 Datenaufbereitung -- 6.8 Inhaltlich strukturierende qualitative Inhaltsanalyse -- 6.8.1 Entwicklung des Codiermanuals I und erster Codierdurchgang -- 6.8.2 Zweiter Codierdurchgang mittels Codiermanual I -- 6.8.3 Zusammenstellung der Codiereinheiten und statistische Analyse -- 6.9 Evaluative qualitative Inhaltsanalyse -- 6.9.1 Entwicklung des Codiermanuals II und erster Codierdurchgang -- 6.9.2 Zweiter Codierdurchgang mittel Codiermanual II -- 6.9.3 Zusammenstellung der Codiereinheiten und kategoriebasierte Analyse -- 7 Forschungsergebnisse -- 7.1 Ergebnisse: Zuwachs an Handlungswissen - quantitativ -- 7.1.1 Ergebnis gesamt -- 7.1.2 Ergebnisse der einzelnen Vignetten -- 7.2 Ergebnisse: Zuwachs an Handlungswissen - evaluativ -- 7.2.1 Ergebnis gesamt -- 7.2.2 Ergebnisse der einzelnen Vignetten -- 7.3 Ergebnisse: Nachhaltigkeit des Zuwachses an Handlungswissen -- 7.4 Ergebnisse: Auswirkungen von soziodemografischen Merkmalen und Vorerfahrungen -- 8 Diskussion der Ergebnisse -- 8.1 Zuwachs an Handlungswissen -- 8.2 Nachhaltigkeit des Zuwachses an Handlungswissen -- 8.3 Auswirkungen von soziodemografischen Merkmalen und Vorerfahrungen -- 9 Diskussion der Forschungsmethode und Limitationen -- 10 Ausblick -- Literaturverzeichnis -- Reihenübersicht.

Additional Edition: Print version: Rymarczyk, Jutta Gesamtsprachliche Bildung und Frueher Englischunterricht Frankfurt a.M. : Peter Lang GmbH, Internationaler Verlag der Wissenschaften,c2022 ISBN 9783631867556

Language: German

Keywords: Electronic books.

URL: Click to View

URL: EBSCOhost

UID:

Format: 1 online resource (399 pages)

Edition: 1st ed.

ISBN: 9783839437124

Series Statement: Kultur und Kollektiv ; v.4

Note: Cover -- Inhalt -- Prolog: Der Anti-Populismus-Reflex oder die wissenschaftliche Konstitution eines ungeliebten Forschungsgegenstandes -- Einleitung -- 1. Der SV-P Populismus und die Polarisierung der politischen Schweiz -- 2. Theoretische Perspektive und Fragestellung -- 3. Aufbau der Arbeit -- 4. Forschungsüberblick -- ERSTER TEIL: DISKURS, HEGEMONIE, POPULISMUS. ERNESTO LACLAUS POLITISCHE THEORIE DER GESELLSCHAFT -- 1. Das ‚Volk' als imaginäre und reale Identität -- 2. Populismusforschung als Parteienforschung: der Gelegenheitsstrukturansatz -- 2.1 Das Erklärungsmodell und die theoretischen Prämissen des Gelegenheitsstrukturansatzes -- 2.2 Populismusforschung ohne ‚Volk'. Grenzen des Gelegenheitsstrukturansatzes -- 2.3 Plädoyer für einen Paradigmenwechsel in der Erforschung populistischer Parteien -- 3. Konzeptuelle Vorbemerkungen: Identität und Hegemonie -- 3.1 Der Forschungsgegenstand: Identität -- 3.2 Der sozialtheoretische Scheinwerfer: Hegemonie -- 3.3 Eine hegemonietheoretische Konzeption des Identitätsbegriffs -- 4. Antagonistische Ordnungen. Ernesto Laclaus und Chantal Mouffes poststrukturalistische Diskurstheorie des Sozialen -- 4.1 Theoretische Grundlagen I: Von performativen Sprachspielen und Sprechakten zu einer Diskurstheorie des Sozialen -- 4.2 Theoretische Grundlagen II: Poststrukturalismus, discursive turn und postfundamentalistische Epistemologie -- 4.3 Eckpunkte einer poststrukturalistischen Diskurstheorie -- 4.4 Die konzeptuellen Bausteine der Hegemonietheorie -- 4.4.1 Artikulation, Diskurs, Knotenpunkte -- 4.4.2 Antagonismus, Dislokation und das Subjekt als Mangel -- 4.4.3 Die Subversion von Bedeutung: Die wechselseitige Kontamination von Äquivalenz- und Differenzlogik -- 4.4.4 Leere Signifikanten und Hegemonie: Semantische Entleerungen als Möglichkeitsbedingung provisorischer Universalisierungen. , 4.5 Die Unmöglichkeit von Gesellschaft und das Primat des Politischen -- 4.6 Die politische Ethik der radikalen Demokratie 11 -- 5. Populismus als politisches Phänom en par excellence 1 -- 5.1 Die binäre Spaltung des Sozialen und die hegemoniale Konstruktion des ‚Volkes' -- 5.2 Populismus als Königsweg des Politischen - und der Demokratie? -- 6. Für eine Hegemonieanalyse rechtspopulistischer Diskurse -- ZWEITER TEIL: VON DER THEORIE ZUR FORSCHUNGSSTRATEGIE -- 1. Operationalisierung und Untersuchungsmaterial -- 1.1 Wie sich die Fixierung von Sinn untersuchen lässt. Eine textanalytisch orientierte Operationalisierung der Hegemonietheorie -- 1.2 Eine forschungspragmatische Auswahl von vier dislozierenden Ereignissen als Wegmarken der Hegemonieanalyse -- 1.3 Untersuchungsmaterial -- DRITTER TEIL: EINE HEGEMONIEANALYSE DES SVP-POPULISMUS -- 1. No Country for Populist Leaders ? -- 1.1 Der ‚konkordanzdemokratische Sonderfall'. Zur hegemonialen Konstruktion der politischen Schweiz zwischen 1945 und 1990 -- 1.2 Der SVP-Populismus und die Krise der konkordanzdemokratisch integrierten Schweiz -- 2. Blochers ‚Neue Mitte' und die Radikalisierung des Zürcher Flügels: Von der klientelistischen Bauern- und Gewerbepartei zur neukonservativen Catch-All-Partei -- 2.1 Die Pionierphase des SVP-Populismus: Die Zürcher Antwort auf die Krise der SVP -- 2.2 Die Konstruktion einer liberalkonservativen Äquivalenz -- 2.2.1 Neoliberalismus - die ordnungspolitische Offensive -- 2.2.2 Konservatismus - die sicherheitspolitische Offensive -- 3. Zwischenbilanz und Vorausblick: Von der subkulturellen Enklave zum nationalpopularen politischen Projekt -- 4. Der populare Bruch: Der Konflikt um die europäische Integration und die Konstruktion eines nationalpopularen Neoliberalismus. , 4.1 Das Nein zum Europäischen Wirtschaftraum. Ursachen und Folgen der Volksabstimmung vom 6. Dezember 1992 -- 4.2 Einschub: Die Albisgüetli-Tagung der Zürcher SVP -- 4.3 Die Albisgüetlirede von 1992 -- 4.4 Die EG als sozialistisches Rezidiv und die liberal-konservative Usurpation des ‚Schweizer Sonderfalls' -- 4.5 Missionarische Politik und popularer Bruch -- 4.6 Zusammenfassung: Die ‚orientierungslose politische Klasse' und die Überdeterminierung der popularen Äquivalenz -- 5. Die Heydays des SVP-Populismus und die rechtspopulistische Hegemonisierung des nationalpopularen Imaginären -- 5.1 Die Nationalratswahlen 1999 -- 5.2 Geschichtspolitik: Die Konstruktion eines Heartland -- 5.2.1 Das Organische und das Zersetzende -- 5.2.2 Blocher & -- Co als Helden einer zyklisch-periodisch verlaufenden Geschichte. Von ‚schweizerischen Gemeinschaften' und ‚europäischen Massengesellschaften' -- 5.2.3 Zusammenfassung: Die geschichtspolitische Hegemonisierung des ‚Sonderfalls' -- 5.3 Demokratie und Pluralismus. Zur semantischen Transformation identitätsstiftender Begriffe im SVP-Populismus -- 6. Gegenhegemonien: Swissness oder Sonderfall. Post-politische Restauration der multikulturellen Schweiz oder linkspopulistische Gegenhegemonie -- 7. ‚Blocherismus' -- 7.1 Das Ereignis: Die Nationalratswahlen 2007 und die Abwahl Christoph Blochers als Bundesrat -- 7.2 Christoph Blocher: Bauer, Jurist, Oberst, Unternehmer, Kunstsammler. Die Karriere des politischen Versorgers und Gesetzgebers -- 7.3 Der Abgewählte als verhinderter Heilsbringer. Charisma, politische Repräsentation und missionarische Politik -- 8. Der Minarett-Streit. Der SVP-Populismus zwischen Zersplitterung und Hegemonisierung des demokratischen Imaginären -- 8.1 Minarett-Streit und Minarett-Initiative -- 8.2 Der Antiislamismus und die Europäisierung des popularen Bruchs. , 8.3 Volkssouveränität gegen ‚fremdes Recht'. Die populistische Generalisierung der Bedrohung und die Variation des ‚Sonderfalls' -- SCHLUSS: ANTIPOLITISCHER POPULISMUS -- 1. Die Kontinuität des SVP-Populismus und die Externalisierung innerer Grenzen -- 2. Popular-demokratischer oder autoritärer Populismu s. Das ethische Moment der politischen Ontologie und die Grenzen des Formalismus -- Bibliographie -- Literatur -- Fragmente des SVP-Diskurses -- Danksagung.

Additional Edition: Print version: Hildebrand, Marius Rechtspopulismus und Hegemonie Bielefeld : transcript,c2017 ISBN 9783837637120

Language: German

Subjects: Political Science

Keywords: Electronic books. ; Hochschulschrift ; Hochschulschrift

URL: Click to View

URL: kostenfrei

URL: lizenzpflichtig

URL: Open Access

URL: kostenfrei

URL: Cover

URL: Cover

UID:

Format: 1 online resource (424 pages)

ISBN: 9783969105436

Series Statement: Programmieren mit Java

Note: Intro -- Vorwort -- I Einstieg -- 1 Einführung -- 1.1 Java im Überblick -- 1.2 Los geht's - Installation -- 1.2.1 Java-Download -- 1.2.2 Installation des JDKs -- 1.2.3 Nacharbeiten nach der Java-Installation -- 1.2.4 Java-Installation prüfen -- 1.3 Entwicklungsumgebungen -- 1.3.1 Installation von Eclipse -- 1.3.2 Eclipse starten -- 1.3.3 Erstes Projekt in Eclipse -- 1.3.4 Erste Klasse in Eclipse -- 2 Schnelleinstieg -- 2.1 Hallo Welt (Hello World) -- 2.2 Variablen und Datentypen -- 2.2.1 Definition von Variablen -- 2.2.2 Bezeichner (Variablennamen) -- 2.3 Operatoren im Überblick -- 2.3.1 Arithmetische Operatoren -- 2.3.2 Zuweisungsoperatoren -- 2.3.3 Vergleichsoperatoren -- 2.3.4 Logische Operatoren -- 2.4 Fallunterscheidungen -- 2.5 Methoden -- 2.5.1 Methoden aus dem JDK nutzen -- 2.5.2 Eigene Methoden definieren -- 2.5.3 Nützliche Beispiele aus dem JDK -- 2.5.4 Signatur einer Methode -- 2.5.5 Fehlerbehandlung und Exceptions -- 2.6 Kommentare -- 2.7 Schleifen -- 2.7.1 Die for-Schleife -- 2.7.2 Die for-each-Schleife -- 2.7.3 Die while-Schleife -- 2.7.4 Die do-while-Schleife -- 2.8 Rekapitulation -- 2.9 Weiterführende Dokumentation für nächste Schritte -- 2.10 Aufgaben und Lösungen -- 2.10.1 Aufgabe 1: Mathematische Berechnungen -- 2.10.2 Aufgabe 2: Methode und if -- 2.10.3 Aufgabe 3: Selbstabholerrabatt -- 2.10.4 Aufgabe 4: Schleifen mit Berechnungen -- 2.10.5 Aufgabe 5: Schleifen und fixe Schrittweite -- 2.10.6 Aufgabe 6: Schleifen mit variabler Schrittweite -- 2.10.7 Aufgabe 7: Verschachtelte Schleifen - Variante 1 -- 2.10.8 Aufgabe 8: Verschachtelte Schleifen - Variante 2 -- 2.10.9 Aufgabe 9: Verschachtelte Schleifen - Variante 3 -- 3 Strings -- 3.1 Schnelleinstieg -- 3.1.1 Gebräuchliche Stringaktionen -- 3.1.2 Suchen und Ersetzen -- 3.1.3 Informationen extrahieren und formatieren -- 3.2 Nächste Schritte -- 3.2.1 Die Klasse Scanner , 3.2.2 Mehrzeilige Strings (Text Blocks) -- 3.2.3 Strings und char[]s -- 3.3 Praxisbeispiel: Text in Title Case wandeln -- 3.4 Aufgaben und Lösungen -- 3.4.1 Aufgabe 1: Länge, Zeichen und Enthaltensein -- 3.4.2 Aufgabe 2: Title Case mit Scanner -- 3.4.3 Aufgabe 3: Zeichen wiederholen -- 3.4.4 Aufgabe 4: Vokale raten -- 3.4.5 Aufgabe 5: String Merge -- 4 Arrays -- 4.1 Schnelleinstieg -- 4.1.1 Gebräuchliche Aktionen -- 4.1.2 Mehrdimensionale Arrays -- 4.2 Nächste Schritte -- 4.2.1 Eindimensionale Arrays -- 4.2.2 Mehrdimensionale Arrays -- 4.3 Praxisbeispiel: Flächen füllen -- 4.4 Aufgaben und Lösungen -- 4.4.1 Aufgabe 1: Durcheinanderwürfeln eines Arrays -- 4.4.2 Aufgabe 2: Arrays kombinieren -- 4.4.3 Aufgabe 3: Rotation um eine oder mehrere Positionen -- 4.4.4 Aufgabe 4: Zweidimensionales String-Array ausgeben -- 4.4.5 Aufgabe 5: Dreieckiges Array: Upside Down -- 5 Klassen und Objektorientierung -- 5.1 Schnelleinstieg -- 5.1.1 Grundlagen zu Klassen und Objekten -- 5.1.2 Eigenschaften (Attribute) -- 5.1.3 Verhalten (Methoden) -- 5.1.4 Objekte vergleichen - die Rolle von equals() -- 5.2 Nächste Schritte -- 5.2.1 Klassen ausführbar machen -- 5.2.2 Imports und Packages -- 5.2.3 Übergang zum Einsatz einer IDE -- 5.2.4 Imports und Packages: Auswirkungen auf unsere Applikation -- 5.2.5 Verstecken von Informationen -- 5.3 Vererbung -- 5.3.1 Basisklassen und abstrakte Basisklassen -- 5.3.2 Overloading und Overriding -- 5.4 Die Klasse Object -- 5.4.1 Beispielklasse Person -- 5.4.2 Die Methode toString() -- 5.4.3 Ergänzungen zur Methode equals(Object) -- 5.4.4 Typprüfung mit instanceof -- 5.4.5 Pattern Matching bei instanceof -- 5.5 Schnittstelle (Interface) und Implementierung -- 5.6 Records -- 5.7 Aufgaben und Lösungen -- 5.7.1 Aufgabe 1: Obstkorb -- 5.7.2 Aufgabe 2: Superheld -- 5.7.3 Aufgabe 3: Zähler -- 5.7.4 Aufgabe 4: Zähler mit Überlauf -- 6 Collections , 6.1 Schnelleinstieg -- 6.1.1 Die Klasse ArrayList -- 6.1.2 Die Klasse HashSet -- 6.1.3 Iteratoren -- 6.1.4 Die Klasse HashMap -- 6.2 Nächste Schritte -- 6.2.1 Generische Typen (Generics) -- 6.2.2 Basisinterfaces für die Containerklassen -- 6.3 Praxisbeispiel: Einen Stack selbst realisieren -- 6.4 Aufgaben und Lösungen -- 6.4.1 Aufgabe 1: Tennisverein-Mitgliederliste -- 6.4.2 Aufgabe 2: Liste mit Farbnamen füllen und filtern -- 6.4.3 Aufgabe 3: Duplikate entfernen - Variante 1 -- 6.4.4 Aufgabe 4: Duplikate entfernen - Variante 2 -- 6.4.5 Aufgabe 5: Hauptstädte -- 6.4.6 Aufgabe 6: Häufigkeiten von Namen -- 6.4.7 Aufgabe 7: Objekte mit Maps selbst gebaut -- 6.4.8 Aufgabe 8: Listenreihenfolge umdrehen (mit Stack) -- 7 Ergänzendes Wissen -- 7.1 Sichtbarkeits- und Gültigkeitsbereiche -- 7.2 Primitive Typen und Wrapper-Klassen -- 7.2.1 Grundlagen -- 7.2.2 Casting: Typerweiterungen sowie -verkleinerungen -- 7.2.3 Konvertierung von Werten -- 7.3 Ternary-Operator (?-Operator) -- 7.4 Aufzählungen mit enum -- 7.5 Switch -- 7.6 Moderne Switch Expressions -- 7.6.1 Einführendes Beispiel -- 7.6.2 Weitere Gründe für die Neuerung -- 7.7 Pattern Matching bei Switch Expressions (Java 17 Preview) -- 7.7.1 Einführendes Beispiel -- 7.7.2 Spezialitäten -- 7.8 Break und Continue in Schleifen -- 7.8.1 Funktionsweise von break und continue in Schleifen -- 7.8.2 Wie macht man es besser? -- 7.9 Rekursion -- 7.10 Aufgaben und Lösungen -- 7.10.1 Aufgabe 1: Würfelspiel -- 7.10.2 Aufgabe 2: Prüfung auf Vokale mit switch -- 7.10.3 Aufgabe 3: Temperaturumrechnung -- 7.10.4 Aufgabe 4: Palindrom-Prüfung mit Rekursion -- II Aufstieg -- 8 Mehr zu Klassen und Objektorientierung -- 8.1 Wissenswertes zu Vererbung -- 8.1.1 Generalisierung und Spezialisierung -- 8.1.2 Polymorphie -- 8.1.3 Sub-Classing und Sub-Typing -- 8.2 Varianten innerer Klassen -- 8.2.1 »Normale« innere Klassen , 8.2.2 Statische innere Klassen -- 8.2.3 Methodenlokale innere Klassen -- 8.2.4 Anonyme innere Klassen -- 9 Lambdas und Streams -- 9.1 Einstieg in Lambdas -- 9.1.1 Syntax von Lambdas -- 9.1.2 Functional Interfaces und SAM-Typen -- 9.2 Methodenreferenzen -- 9.3 Externe vs. interne Iteration -- 9.3.1 Externe Iteration -- 9.3.2 Interne Iteration -- 9.3.3 Das Interface Predicate< -- T> -- -- 9.4 Streams im Überblick -- 9.4.1 Streams erzeugen - Create Operations -- 9.4.2 Intermediate und Terminal Operations im Überblick -- 9.4.3 Zustandslose Intermediate Operations -- 9.4.4 Zustandsbehaftete Intermediate Operations -- 9.4.5 Terminal Operations -- 9.5 Aufgaben und Lösungen -- 9.5.1 Aufgabe 1: Erwachsene aus Personenliste extrahieren -- 9.5.2 Aufgabe 2: Stream-API -- 9.5.3 Aufgabe 3: Informationen mit Stream-API extrahieren -- 9.5.4 Aufgabe 4: Häufigkeiten von Namen -- 9.5.5 Aufgabe 5: Kollektoren -- 10 Verarbeitung von Dateien -- 10.1 Schnelleinstieg -- 10.1.1 Das Interface Path und die Utility-Klasse Files -- 10.1.2 Anlegen von Dateien und Verzeichnissen -- 10.1.3 Inhalt eines Verzeichnisses auflisten -- 10.1.4 Pfad ist Datei oder Verzeichnis? -- 10.1.5 Dateiaktionen und die Utility-Klasse Files -- 10.1.6 Informationen zu Path-Objekten ermitteln -- 10.1.7 Kopieren -- 10.1.8 Umbenennen -- 10.1.9 Löschen -- 10.2 Dateibehandlung und die Klasse File -- 10.2.1 Konvertierung von Path in File und zurück -- 10.2.2 Die Klasse File im Kurzüberblick -- 10.2.3 Dateiinhalte verarbeiten und Systemressourcen -- 10.3 Praxisbeispiel: Directory-Baum darstellen -- 10.3.1 Basisvariante -- 10.3.2 Variante mit schönerer Darstellung -- 10.3.3 Finale Variante mit ausgeklügelter Darstellung -- 10.4 Aufgaben und Lösungen -- 10.4.1 Aufgabe 1: Texte in Datei schreiben und wieder lesen -- 10.4.2 Aufgabe 2: Dateigrößen -- 10.4.3 Aufgabe 3: Existenzprüfung , 10.4.4 Aufgabe 4: Rechteprüfung -- 10.4.5 Aufgabe 5: Verzeichnisinhalt auflisten -- 11 Fehlerbehandlung mit Exceptions -- 11.1 Schnelleinstieg -- 11.1.1 Fehlerbehandlung -- 11.1.2 Exceptions selbst auslösen - throw -- 11.1.3 Eigene Exception-Typen definieren -- 11.1.4 Exceptions propagieren - throws -- 11.2 Fehlerbehandlung in der Praxis -- 11.3 Automatic Resource Management (ARM) -- 11.4 Hintergrundwissen: Checked und Unchecked Exceptions -- 12 Datumsverarbeitung -- 12.1 Schnelleinstieg -- 12.1.1 Die Aufzählungen DayOfWeek und Month -- 12.1.2 Die Klasse LocalDate -- 12.1.3 Die Klassen LocalTime und LocalDateTime -- 12.2 Nächste Schritte -- 12.2.1 Datumsarithmetik -- 12.2.2 Formatierung und Parsing -- 12.3 Praxisbeispiel: Kalenderausgabe -- 12.4 Aufgaben und Lösungen -- 12.4.1 Aufgabe 1: Wochentage -- 12.4.2 Aufgabe 2: Freitag, der 13. -- 12.4.3 Aufgabe 3: Mehrmals Freitag, der 13. -- 12.4.4 Aufgabe 4: Schaltjahre -- III Praxisbeispiele -- 13 Praxisbeispiel: Tic Tac Toe -- 13.1 Spielfeld initialisieren und darstellen -- 13.2 Setzen der Steine -- 13.3 Prüfen auf Sieg -- 13.4 Bausteine im Einsatz -- 14 Praxisbeispiel: CSV-Highscore-Liste einlesen -- 14.1 Verarbeitung von Spielständen (Highscores) -- 14.2 Extraktion der Daten -- 14.3 Besonderheiten der Implementierung -- 15 Praxisbeispiel: Worträtsel -- 15.1 Applikationsdesign - Vorüberlegungen zur Strukturierung -- 15.2 Einlesen der verfügbaren Wörter -- 15.3 Hilfsdatenstrukturen -- 15.4 Datenmodell -- 15.4.1 Datenspeicherung und Initialisierung -- 15.4.2 Zufällige Wahl von Richtung, Position, Wort und Buchstabe -- 15.4.3 Algorithmus zum Verstecken von Wörtern -- 15.4.4 Wort prüfen und platzieren -- 15.5 HTML-Erzeugung -- 15.6 Hauptapplikation -- 15.7 Ausgabe als HTML und Darstellung im Browser -- 15.8 Fazit -- IV Schlussgedanken -- 16 Gute Angewohnheiten , 16.1 Grundregeln eines guten Programmierstils

Additional Edition: Print version: Inden, Michael Einfach Java Heidelberg : dpunkt.verlag,c2021 ISBN 9783864908521

Keywords: Electronic books.

URL: https://ebookcentral.proquest.com/lib/th-brandenburg/detail.action?docID=6719405

URL: https://static.onleihe.de/content/bookwire_nat/20210903/9783969105436/v9783969105436.pdf

URL: https://static.onleihe.de/images/bookwire_nat/20210903/9783969105436/tn9783969105436l.jpg

URL: https://voebb.onleihe.de/berlin/frontend/mediaInfo,51-0-1603545409-100-0-0-0-0-0-0-0.html

UID:

Format: 1 online resource (192 pages)

Edition: 1

ISBN: 9783960104995

Series Statement: Animals

Note: Intro -- Inhalt -- Kapitel 1: Einführung (es geht immer um Komplexität) -- Wie Sie dieses Buch einsetzen -- Kapitel 2: Die Natur der Komplexität -- Definition der Komplexität -- Symptome der Komplexität -- Ursachen für Komplexität -- Komplexität ist inkrementell -- Zusammenfassung -- Kapitel 3: Funktionierender Code reicht nicht aus (strategische versus taktische Programmierung) -- Taktische Programmierung -- Strategische Programmierung -- Wie viel soll ich investieren? -- Start-ups und Investitionen -- Zusammenfassung -- Kapitel 4: Module sollten tief sein -- Modulares Design -- Was ist eine Schnittstelle? -- Abstraktionen -- Tiefe Module -- Flache Module -- Klassizitis -- Beispiele: Java und Unix-I/O -- Zusammenfassung -- Kapitel 5: Information Hiding (und Lecks) -- Information Hiding -- Informationslecks -- Zeitliche Dekomposition -- Beispiel: HTTP-Server -- Beispiel: Zu viele Klassen -- Beispiel: HTTP-Parameter-Handling -- Beispiel: Standardwerte in HTTP-Responses -- Information Hiding in einer Klasse -- Wann Sie zu weit gehen -- Zusammenfassung -- Kapitel 6: Vielseitige Module sind tiefer -- Gestalten Sie Klassen halbwegs vielseitig -- Beispiel: Text für einen Editor speichern -- Eine vielseitigere API -- Vielseitigkeit führt zu besserem Information Hiding -- Fragen, die Sie sich stellen sollten -- Spezialisierung nach oben (und unten!) schieben -- Beispiel: Undo-Mechanismus für den Editor -- Spezialfälle wegdesignen -- Zusammenfassung -- Kapitel 7: Verschiedene Schichten, verschiedene Abstraktionen -- Pass-Through-Methoden -- Wann ist es in Ordnung, Schnittstellen doppelt zu haben? -- Das Decorator-Design-Pattern -- Schnittstelle versus Implementierung -- Pass-Through-Variablen -- Zusammenfassung -- Kapitel 8: Komplexität nach unten ziehen -- Beispiel: Texteditor-Klasse -- Beispiel: Konfigurationsparameter -- Wann Sie zu weit gehen , Zusammenfassung -- Kapitel 9: Zusammen oder getrennt? -- Zusammenbringen bei gemeinsamen Informationen -- Zusammenbringen, um die Schnittstelle zu vereinfachen -- Zusammenbringen, um doppelten Code zu vermeiden -- Trennen von allgemeinem und speziellem Code -- Beispiel: Einfügecursor und Auswahl -- Beispiel: Getrennte Klasse zum Loggen -- Methoden aufteilen und zusammenführen -- Eine andere Meinung: Clean Code -- Zusammenfassung -- Kapitel 10: Definieren Sie die Existenz von Fehlern weg -- Warum Exceptions zur Komplexität beitragen -- Zu viele Exceptions -- Die Existenz von Fehlern wegdefinieren -- Beispiel: Datei löschen in Windows -- Beispiel: substring-Methode in Java -- Exceptions maskieren -- Aggregieren von Exceptions -- Einfach abstürzen? -- Wann Sie zu weit gehen -- Zusammenfassung -- Kapitel 11: Designen Sie zweimal -- Kapitel 12: Warum Kommentare schreiben? - Die vier Ausreden -- Guter Code dokumentiert sich selbst -- Ich habe keine Zeit, Kommentare zu schreiben -- Kommentare veralten und sind dann irreführend -- Die Kommentare, die ich gesehen habe, sind alle nutzlos -- Die Vorteile gut geschriebener Kommentare -- Eine andere Meinung: Kommentare sind Fehler -- Kapitel 13: Kommentare sollten Dinge beschreiben, die im Code nicht offensichtlich sind -- Konventionen -- Wiederholen Sie nicht den Code -- Kommentare auf niedrigerer Ebene sorgen für Präzision -- Kommentare auf höherer Ebene verbessern die Intuition -- Schnittstellendokumentation -- Implementierungskommentare: was und warum, nicht wie -- Modulübergreifende Designentscheidungen -- Zusammenfassung -- Antworten auf die Fragen aus dem Abschnitt »Schnittstellendokumentation« auf Seite 123 -- Kapitel 14: Namen auswählen -- Beispiel: Schlechte Namen führen zu Fehlern -- Ein Bild schaffen -- Namen sollten präzise sein -- Namen konsistent einsetzen -- Vermeiden Sie überflüssige Wörter , Eine andere Meinung: Go Style Guide -- Zusammenfassung -- Kapitel 15: Erst die Kommentare schreiben (nutzen Sie Kommentare als Teil des Designprozesses) -- Aufgeschobene Kommentare sind schlechte Kommentare -- Erst die Kommentare schreiben -- Kommentare sind ein Designwerkzeug -- Frühes Kommentieren macht Spaß -- Sind frühe Kommentare teuer? -- Zusammenfassung -- Kapitel 16: Bestehenden Code anpassen -- Bleiben Sie strategisch -- Kommentare pflegen: Halten Sie die Kommentare nahe am Code -- Kommentare gehören in den Code, nicht in das Commit-Log -- Kommentare pflegen: Vermeiden Sie Duplikate -- Kommentare pflegen: Schauen Sie auf die Diffs -- Kommentare auf höherer Ebene lassen sich leichter pflegen -- Kapitel 17: Konsistenz -- Beispiele für Konsistenz -- Konsistenz sicherstellen -- Wann Sie zu weit gehen -- Zusammenfassung -- Kapitel 18: Code sollte offensichtlich sein -- Dinge, die Code offensichtlicher machen -- Dinge, die Code weniger offensichtlich machen -- Zusammenfassung -- Kapitel 19: Softwaretrends -- Objektorientierte Programmierung und Vererbung -- Agile Entwicklung -- Unit Tests -- Test-Driven Development -- Design Patterns -- Getter und Setter -- Zusammenfassung -- Kapitel 20: Performance -- Wie man über Performance nachdenkt -- Vor (und nach) dem Ändern messen -- Rund um den kritischen Pfad designen -- Ein Beispiel: RAMCloud-Buffer -- Zusammenfassung -- Kapitel 21: Entscheiden, was wichtig ist -- Wie entscheidet man, was wichtig ist? -- Lassen Sie möglichst wenig wichtig sein -- Wie Sie wichtige Dinge hervorheben -- Fehler -- Denken Sie umfassender -- Kapitel 22: Zusammenfassung -- Index

Additional Edition: Print version: Ousterhout, John Prinzipien des Softwaredesigns Heidelberg : o'Reilly,c2021 ISBN 9783960091592

Keywords: Electronic books.

URL: https://ebookcentral.proquest.com/lib/th-brandenburg/detail.action?docID=6800825

URL: https://static.onleihe.de/content/bookwire_nat/20211109/9783960104995/v9783960104995.pdf

URL: https://static.onleihe.de/images/bookwire_nat/20211109/9783960104995/tn9783960104995l.jpg

URL: https://voebb.onleihe.de/berlin/frontend/mediaInfo,51-0-1646278530-100-0-0-0-0-0-0-0.html

UID:

Format: 1 online resource (567 pages)

Edition: 1

ISBN: 9783836263924

Note: Intro -- Materialien zum Buch -- 1 Vorwort -- 1.1 Vorwort der Autoren -- 1.2 Geleitwort -- 2 Einführung -- 2.1 Was ist die Blockchain? -- 2.1.1 Herausforderungen des Internets -- 2.1.2 Die Blockchain -- 2.1.3 Die Blockchain als Problemlöser -- 2.2 Geschichte der Blockchain -- 2.2.1 Pioniere der Blockchain -- 2.2.2 Bitcoin -- 2.2.3 Altcoins -- 2.2.4 Blockchain 2.0 -- 2.2.5 Gegenwart und Zukunft -- 2.3 Anwendung der Blockchain-Technologie -- 2.3.1 Entscheidungskriterien für die Blockchain -- 2.3.2 Blockchain-Varianten -- 2.3.3 Branchen mit Blockchain-Potenzial -- 2.3.4 Realbeispiele für Blockchain-Anwendungen -- 2.4 Zusammenfassung -- 3 Die Basics: So funktioniert eine Blockchain -- 3.1 Kryptografische Grundlagen -- 3.1.1 Einführung in die Kryptografie -- 3.1.2 Elliptic Curve Cryptography (ECC) -- 3.1.3 Kryptografische Hashfunktionen -- 3.2 Die Blockchain -- 3.2.1 Transaktionen -- 3.2.2 Vom Block zur Blockchain -- 3.2.3 Das Blockchain-System -- 3.2.4 Weiterentwicklungen der Blockchain -- 3.3 Die Blockchain 2.0 -- 3.3.1 Einführung und Grundlagen -- 3.3.2 Accounts und State Trie -- 3.3.3 Transaktionen und Transaction Trie -- 3.3.4 Receipts und Receipts Trie -- 3.3.5 Vom Block zur Blockchain 2.0 -- 3.3.6 Das Blockchain-System 2.0 -- 3.3.7 Weiterentwicklung der Ethereum-Plattform -- 3.4 Alternative Konsensmodelle -- 3.4.1 Proof-of-Stake (PoS) -- 3.4.2 Delegated Byzantine Fault Tolerance (dBFT) -- 3.4.3 Proof-of-Activity -- 3.4.4 Proof-of-Importance -- 3.4.5 Proof-of-Authority -- 3.4.6 Proof-of-Reputation -- 3.4.7 Proof-of-Capacity/Proof-of-Space -- 3.4.8 Proof-of-Elapsed-Time -- 3.4.9 Proof-of-Burn -- 3.5 Sicherheit der Blockchain -- 3.5.1 Blockchain und Informationssicherheit -- 3.5.2 Angriffsszenarien -- 3.6 Zusammenfassung -- 4 Eine eigene Blockchain erstellen - Grundfunktionen -- 4.1 Transaktionen - die kleinste Einheit , 4.2 Blockheader - der Inhalt der Block-ID -- 4.3 Die Blöcke verketten -- 4.4 Die Blockchain auf die Festplatte speichern -- 4.5 Der Genesis Block - die Entstehung einer Blockchain -- 4.6 Ausstehende Transaktionen -- 4.7 Die Difficulty einer Blockchain -- 4.8 Zeit zu schürfen - der Miner Thread -- 4.9 Zusammenfassung und Ausblick -- 5 Die Blockchain an eine Web-API anbinden -- 5.1 Die Service-Endpunkte der Web-API -- 5.1.1 Die Service-Klasse für Blöcke implementieren -- 5.1.2 Die Service-Klasse für Transaktionen implementieren -- 5.2 Deployment der Web-API -- 5.2.1 Erstellen einer Ressourcenkonfiguration -- 5.2.2 Einrichten eines embedded Tomcat -- 5.2.3 Die ausgelieferten JSON-Repräsentationen überprüfen -- 5.3 Transaktionen per Webinterface versenden -- 5.4 Einen eigenen Block-Explorer implementieren -- 5.4.1 Transaktionen erkunden -- 5.4.2 Blöcke erkunden -- 5.4.3 Startseite und Suchfunktion implementieren -- 5.5 Zusammenfassung und Ausblick -- 6 Ein Peer-to-Peer-Netzwerk aufbauen -- 6.1 Das Peer-to-Peer-Framework konfigurieren -- 6.2 Transaktionen im Netzwerk verteilen -- 6.3 Blöcke im Netzwerk verteilen -- 6.4 Mehrere Chains parallel verarbeiten -- 6.4.1 Chains aufbewahren und bei Bedarf wechseln -- 6.4.2 Ausstehende Transaktionen beim Chain-Wechsel aktualisieren -- 6.5 Neue Knoten im Netzwerk aufnehmen -- 6.6 Zusammenfassung und Ausblick -- 7 Accounts und Guthaben einführen -- 7.1 Die Miner belohnen -- 7.1.1 Den Minern einen Account zuweisen -- 7.1.2 Accounts persistent speichern -- 7.1.3 Den Blöcken einen Miner zuweisen -- 7.2 Die Accounts verwalten -- 7.2.1 Accounts speichern -- 7.2.2 Accounts initialisieren und aktualisieren -- 7.2.3 Account-Informationen über die Web-API bereitstellen -- 7.3 Die Accounts integrieren -- 7.4 Die Accounts im Block-Explorer einbinden -- 7.4.1 Accounts mit dem Block-Explorer einsehen , 7.4.2 Accounts im Webclient generieren -- 7.4.3 Accounts im Block-Explorer verlinken und suchen -- 7.5 Zusammenfassung und Ausblick -- 8 Verifikation und Optimierungen umsetzen -- 8.1 Transaktionen signieren -- 8.1.1 Digitale Signaturen im Webclient einführen -- 8.1.2 Digitale Signaturen im Backend unterstützen -- 8.2 Die Rahmenbedingungen erzwingen -- 8.2.1 Transaktionen verifizieren -- 8.2.2 Blöcke verifizieren -- 8.3 Guthaben sperren und entsperren -- 8.4 Mit dem Merkle-Baum die Performance optimieren -- 8.4.1 Die Struktur des Merkle-Baums erstellen -- 8.4.2 Den Merkle-Baum über die Web-API nutzen -- 8.5 Den Public Key verkürzen zum Sparen von Speicher -- 8.6 Startguthaben über den Genesis Block ermöglichen -- 8.7 Weitere Optimierungen bedenken -- 8.8 Zusammenfassung und Ausblick -- 9 Smart Contract Development -- 9.1 Einführung -- 9.2 Einfache Smart Contracts bei Bitcoin -- 9.2.1 Bitcoin Script -- 9.2.2 Smart Contracts mit Bitcoin Script -- 9.2.3 Höhere Programmiersprachen für Bitcoin -- 9.3 Anspruchsvolle Smart Contracts -- 9.3.1 Bitcoin-Erweiterungen -- 9.3.2 Smart Contracts mit Ethereum -- 9.4 Zusammenfassung -- 10 Solidity - Die Grundlagen verstehen -- 10.1 Was ist Solidity? -- 10.1.1 Die offizielle Entwicklungsumgebung Remix -- 10.1.2 Aufbau eines Sourcefiles -- 10.1.3 Den ersten Smart Contract erstellen -- 10.1.4 Den ersten Smart Contract lokal deployen -- 10.2 Elemente und Speicherbereiche eines Contracts -- 10.2.1 Die Speicherbereiche verstehen -- 10.2.2 Sichtbarkeiten von Solidity korrekt nutzen -- 10.2.3 Modifier verwenden und selbst definieren -- 10.2.4 Zustandsvariablen deklarieren und initialisieren -- 10.2.5 Contracts erzeugen und zerstören -- 10.2.6 Funktionen implementieren -- 10.2.7 Events definieren und zum Loggen verwenden -- 10.3 Verfügbare Datentypen -- 10.3.1 Primitive Datentypen verwenden -- 10.3.2 Adressen definieren , 10.3.3 Arrays anlegen und nutzen -- 10.3.4 Mehrdimensionale Arrays und ihre Einschränkungen berücksichtigen -- 10.3.5 Structs und Enums definieren -- 10.3.6 Mappings und ihre Besonderheiten verstehen -- 10.3.7 Storage Pointer als Funktionsparameter definieren -- 10.3.8 Funktionen als Variablen verwenden -- 10.4 Zusätzliche Features von Solidity -- 10.4.1 LValues verstehen -- 10.4.2 Variablen löschen und Storage freigeben -- 10.4.3 Elementare Datentypen ineinander umwandeln -- 10.4.4 Typherleitung nutzen -- 10.5 Vererbungshierarchien von Smart Contracts erstellen -- 10.5.1 Wie funktioniert die Vererbung von Contracts? -- 10.5.2 Abstrakte Contracts verwenden -- 10.5.3 Interfaces in Solidity definieren -- 10.6 Libraries erstellen und verwenden -- 10.6.1 Eine eigene Library implementieren -- 10.6.2 Libraries in Contracts verwenden -- 10.6.3 Datentypen mit Libraries erweitern -- 10.7 Zusammenfassung und Ausblick -- 11 Solidity - Details und Herausforderungen -- 11.1 Wichtige Details zu Funktionen -- 11.1.1 Polymorphismus richtig anwenden -- 11.1.2 Funktionen überladen -- 11.1.3 Ether empfangen mit der Fallback-Funktion -- 11.2 Gas verstehen und optimieren -- 11.3 Den richtigen Exception-Mechanismus wählen -- 11.4 Solidity mit Assembly erweitern -- 11.4.1 Inline Assembly in Solidity anwenden -- 11.4.2 Inline Assembly mit dem funktionalen Stil schreiben -- 11.4.3 Inline Assembly über Instruktionen schreiben -- 11.4.4 Standalone Assembly als Alternative zu Solidity verwenden -- 11.4.5 Joyfully Universal Language for (Inline) Assembly -- 11.5 Leicht verständliche Contracts entwickeln -- 11.6 Updatefähige Contracts entwickeln -- 11.6.1 Separation Pattern anwenden -- 11.6.2 Proxy Pattern anwenden -- 11.7 Warum kein Zufallsgenerator sicher ist -- 11.7.1 Blockvariablen verwenden -- 11.7.2 Fortlaufende Nummern verwenden -- 11.7.3 Zweistufige Lotterien verwenden , 11.7.4 Zufall außerhalb der Blockchain ermitteln -- 11.8 Daten von außerhalb der Blockchain vertrauen -- 11.9 Zeitabhängigkeiten einbauen -- 11.9.1 Zeitabhängigkeiten über die Blockzeit prüfen -- 11.9.2 Externe Services verwenden -- 11.10 Zusammenfassung und Ausblick -- 12 Smart Contracts testen und debuggen -- 12.1 Contracts mit Remix testen -- 12.1.1 Unittests innerhalb von Remix ausführen -- 12.1.2 Remix-Tests in Continuous-Integration-Systeme integrieren -- 12.2 Debugging mit Remix -- 12.3 Einführung in das Truffle Framework -- 12.3.1 Das Truffle Framework aufsetzen -- 12.3.2 Migrationen in Truffle verwenden -- 12.4 Unittests mit Truffle implementieren -- 12.4.1 Unittests in Solidity mit den Truffle-Funktionen implementieren -- 12.4.2 Exceptions mit dem Truffle Framework testen -- 12.4.3 Unittests für Ether-Transaktionen implementieren -- 12.5 Integrationstests mit Truffle implementieren -- 12.5.1 Mit Contracts im JavaScript-Code interagieren -- 12.5.2 Unterschiedliche Schreibweisen verstehen -- 12.5.3 Testläufe starten und auswerten -- 12.5.4 Events in JavaScript überprüfen -- 12.6 Mit dem Truffle Framework debuggen -- 12.7 Zusammenfassung und Ausblick -- 13 Smart Contracts schützen und absichern -- 13.1 Allgemeine Sicherheitsempfehlungen -- 13.1.1 Sichtbarkeiten explizit angeben -- 13.1.2 Konstruktoren nur über das Schlüsselwort definieren -- 13.1.3 Storage Pointer immer initialisieren -- 13.1.4 Race Conditions im Hinterkopf behalten -- 13.1.5 Rückgabewerte von Low-Level-Funktionen überprüfen -- 13.1.6 Manipulationen durch Miner berücksichtigen -- 13.2 Ether in Contracts schmuggeln -- 13.3 Arithmetische Overflows und Underflows -- 13.4 Mit DelegateCalls den Zustand manipulieren -- 13.5 Reentrancy-Angriffe durchführen -- 13.6 Denial-of-Service-Angriffe durchführen -- 13.7 Gas-Siphoning-Angriffe beachten -- 13.8 Zusammenfassung und Ausblick , 14 Smart Contracts deployen und managen

Additional Edition: Print version: Schütz, Andreas Blockchain für Entwickler Bonn : Rheinwerk Verlag,c2019 ISBN 9783836263900

Keywords: Electronic books.

URL: https://ebookcentral.proquest.com/lib/th-brandenburg/detail.action?docID=6382542

URL: http://www.onleihe.de/static/content/rheinwerk/20190221/9783836263924/v9783836263924.pdf

URL: http://www.onleihe.de/static/images/rheinwerk/20190221/9783836263924/tn9783836263924l.jpg

URL: http://voebb.onleihe.de/berlin/frontend/mediaInfo,51-0-837863531-100-0-0-0-0-0-0-0.html

UID:

Format: 1 Online-Ressource (476 Seiten) , Illustrationen

Edition: 4., aktualisierte Auflage

ISBN: 9783836292665

Content: Nutzen Sie die geniale Game Engine Unity, um eigene Spiele zu entwickeln! Erfolgsautor Thomas Theis zeigt Ihnen Schritt für Schritt, wie es geht - von der ersten Scene bis zum komplexen Multiplayer-Spiel. Mit dem integrierten C#-Kurs lernen Sie ohne Vorkenntnisse und ohne externe Software alle Objekte und Befehle direkt so kennen, wie Sie in Unity-Skripten aussehen. Unity bietet eine Fülle von Techniken und Effekten, die Sie nur einzubinden brauchen. Ob es um Zusammenstöße, Flugkurven, Explosionen oder die Kameraperspektive geht: Lernen Sie erst mit 2D- und dann mit 3D-Spielen, die mächtigen Werkzeuge zu nutzen und Ihre eigenen Ideen umzusetzen. Mit 18 vollständigen Spieleprojekten aus vielen Genres.

Note: Intro -- 1 Einführung -- 1.1 Was machen wir mit Unity? -- 1.2 Wie entsteht der programmierte Spielablauf? -- 1.3 Dateiendungen anzeigen lassen -- 1.4 Unity Hub installieren -- 1.5 Unity-Lizenz erhalten -- 1.6 Unity-Version installieren -- 1.7 Beispielprojekte und Assets -- 1.8 Upgrade eines Unity-Projekts -- 2 Das erste 2D-Projekt -- 2.1 Erstellung eines neuen Projekts -- 2.2 Wichtige Bereiche im Unity Editor -- 2.3 Das Spielobjekt »Main Camera« -- 2.4 Assets importieren -- 2.5 Spielobjekte einfügen -- 2.6 Ändern der Hierarchie -- 2.7 Eine Szene speichern -- 2.8 Die Komponente »Transform« -- 2.8.1 Die Eigenschaften der Transform-Komponente -- 2.8.2 Werte in der »Inspector View« ändern -- 2.9 Die Ansicht in der »Scene View« -- 2.9.1 Positionswerte mithilfe der Maus ändern -- 2.9.2 Rotationswerte mithilfe der Maus ändern -- 2.9.3 Scale-Werte mithilfe der Maus ändern -- 3 Spielen Sie ein 2D-Jump& -- Run-Spiel -- 3.1 Wie geht das Spiel? -- 3.2 Unsere ersten Unity-Elemente -- 3.2.1 Assets -- 3.2.2 Spielobjekte -- 4 Entwickeln Sie ein 2D-Jump& -- Run-Spiel -- 4.1 Erzeugen Sie Projekt und Assets -- 4.2 Fügen Sie Spielobjekte ein -- 4.2.1 Schaffen Sie einen Hintergrund -- 4.2.2 Erzeugen Sie das Spielfeld -- 4.2.3 Setzen Sie den Affen auf den Boden -- 4.3 Erstellen Sie den Spielablauf -- 4.3.1 Stellen Sie »Visual Studio« ein -- 4.3.2 Führen Sie die Klasse »Spieler« ein -- 4.3.3 Bewegen Sie den Affen -- 4.3.4 Anzeige von Fehlern -- 4.3.5 Verhindern Sie die Drehung -- 4.3.6 Begrenzen Sie die Bewegung zur Seite -- 4.3.7 Treffen Sie die Bananen -- 4.3.8 Meiden Sie die Tiger -- 4.3.9 Die geschweiften Klammern -- 4.3.10 Die Tiger bewegen sich -- 4.4 Gestalten Sie die Benutzeroberfläche -- 4.4.1 Erstellen Sie die erste Anzeige -- 4.4.2 Sammeln Sie Punkte -- 4.4.3 Verlieren Sie Leben -- 4.4.4 Messen Sie die Spielzeit -- 4.4.5 Speichern Sie Werte dauerhaft.

Additional Edition: Erscheint auch als Druck-Ausgabe ISBN 9783836292641

Additional Edition: ISBN 3836292645

Language: German

Subjects: Computer Science

Keywords: Computerspiel ; Programmierung ; Unity ; C sharp ; Electronic books.

URL: https://ebookcentral.proquest.com/lib/th-brandenburg/detail.action?docID=7232171

Author information: Theis, Thomas 1960-

UID:

Format: 1 Online-Ressource (527 Seiten)

Edition: 7., aktualisierte Auflage

ISBN: 9783836290050 , 9783836290043

Series Statement: Rheinwerk Computing

Note: Auf dem Umschlag: Keine Vorkenntnisse erforderlich. - Vom ersten Programm bis zur fertigen Anwendung; mit vielen Beispielen und Übungsaufgaben; inkl. Objektorientierung, GUI-Entwicklung, Datenbanken u.v.m. - Alle Codebeispiele und Musterlösungen zum Download , Intro -- Danksagung -- 1 Einführung -- 1.1 Was bedeutet Programmierung? -- 1.1.1 Von den Anfängen bis heute -- 1.1.2 Wozu überhaupt programmieren? -- 1.1.3 Hilfsmittel für den Programmentwurf -- 1.1.4 Von der Idee zum Programm -- 1.1.5 Arten von Programmiersprachen -- 1.2 Java -- 1.2.1 Die Entstehungsgeschichte von Java -- 1.2.2 Merkmale von Java -- 1.2.3 Installation von Java -- 1.3 Ein erstes Java-Programm -- 1.3.1 Die Arbeitsumgebung vorbereiten -- 1.3.2 Wie sind Java-Programme aufgebaut? -- 1.3.3 Schritt für Schritt zum ersten Programm -- 1.3.4 Single-File-Source-Code-Programme , 1.4 Übungsaufgaben -- 1.5 Ausblick -- 2 Grundbausteine eines Java-Programms -- 2.1 Bezeichner und Schlüsselwörter -- 2.2 Kommentare -- 2.3 Variablen und Datentypen -- 2.3.1 Namenskonventionen für Variablen -- 2.3.2 Wertzuweisung -- 2.3.3 Die primitiven Datentypen im Einzelnen -- 2.3.4 Praxisbeispiel 1 zu Variablen -- 2.3.5 Ein häufiger Fehler bei der Variablendeklaration -- 2.3.6 Praxisbeispiel 2 zu Variablen -- 2.3.7 Der Datentyp »String« -- 2.3.8 Der Dialog mit dem Anwender -- 2.3.9 Übungsaufgaben -- 2.4 Operatoren und Ausdrücke -- 2.4.1 Der Zuweisungsoperator und der Cast-Operator , 2.4.2 Vergleiche und Bedingungen -- 2.4.3 Arithmetische Operatoren -- 2.4.4 Priorität -- 2.4.5 Logische Operatoren -- 2.4.6 Sonstige Operatoren -- 2.5 Übungsaufgaben -- 2.6 Ausblick -- 3 Kontrollstrukturen -- 3.1 Anweisungsfolge (Sequenz) -- 3.2 Auswahlstrukturen (Selektionen) -- 3.2.1 Zweiseitige Auswahlstruktur (»if«-Anweisung) -- 3.2.2 Übungsaufgaben zur »if«-Anweisung -- 3.2.3 Mehrseitige Auswahlstruktur (»switch-case«-Anweisung) -- 3.2.4 Übungsaufgabe zur »switch-case«-Anweisung -- 3.3 Wiederholungsstrukturen (Schleifen oder Iterationen) -- 3.3.1 Die »while«-Schleife , 3.3.2 Die »do«-Schleife -- 3.3.3 Die »for«-Schleife -- 3.3.4 Sprunganweisungen -- 3.3.5 Übungsaufgaben zu Schleifen -- 3.4 Auswirkungen auf Variablen -- 3.4.1 Gültigkeitsbereiche -- 3.4.2 Namenskonflikte -- 3.4.3 Lebensdauer -- 3.5 Ausblick -- 4 Einführung in Eclipse -- 4.1 Die Entwicklungsumgebung Eclipse -- 4.1.1 Installation von Eclipse -- 4.1.2 Eclipse starten -- 4.1.3 Ein bestehendes Projekt in Eclipse öffnen -- 4.2 Erste Schritte mit Eclipse -- 4.2.1 Ein neues Projekt erstellen -- 4.2.2 Programm eingeben und starten -- 4.3 Fehlersuche mit Eclipse -- 4.3.1 Fehlersuche ohne Hilfsmittel , 4.3.2 Haltepunkte (Breakpoints) -- 4.4 Ausblick -- 5 Klassen und Objekte -- 5.1 Die Struktur von Java-Programmen -- 5.1.1 Klassen -- 5.1.2 Attribute -- 5.1.3 Packages -- 5.1.4 Module -- 5.2 Objekte -- 5.2.1 Zugriff auf die Attribute (Datenelemente) -- 5.2.2 Wertzuweisungen bei Objekten -- 5.2.3 Gültigkeitsbereich und Lebensdauer -- 5.3 Methoden -- 5.3.1 Der Aufbau von Methoden -- 5.3.2 Der Aufruf von Methoden -- 5.3.3 Abgrenzung von Bezeichnern -- 5.4 Werte übergeben -- 5.4.1 Methoden mit Parameter -- 5.4.2 Referenztypen als Parameter -- 5.4.3 Methoden überladen -- 5.5 Ergebnisse

Additional Edition: Erscheint auch als Druck-Ausgabe ISBN 978-3-8362-9003-6

Language: German

Subjects: Computer Science

Keywords: Objektorientierte Programmierung ; Java Desktop System ; Java ; Java Standard Edition 17 ; Electronic books.

URL: https://ebookcentral.proquest.com/lib/th-brandenburg/detail.action?docID=7030353

Author information: Habelitz, Hans-Peter

UID:

Format: 1 online resource (216 pages)

Edition: 1

ISBN: 9783960103936

Note: Intro -- Inhalt -- Einführung -- Teil I: PyTorch und neuronale Netze -- Kapitel 1: Grundlagen von PyTorch -- Google Colab -- PyTorch-Tensoren -- Automatische Gradienten mit PyTorch -- Berechnungsgraphen -- Lernziele -- Kapitel 2: Erstes neuronales Netz mit PyTorch -- Das MNIST-Bilddatensatz -- Die MNIST-Daten abrufen -- Ein Blick auf die Daten -- Ein einfaches neuronales Netz -- Das Training visualisieren -- Die Klasse für den MNIST-Datensatz -- Unsere Klassifizierer trainieren -- Das neuronale Netz abfragen -- Die Performance des Klassifizierers einfach ermitteln -- Kapitel 3: Verfeinerungen -- Verlustfunktion -- Aktivierungsfunktion -- Optimierungsmethode -- Normalisierung -- Kombinierte Verfeinerungen -- Lernziele -- Kapitel 4: Grundlagen von CUDA -- NumPy vs. Python -- NVIDIA CUDA -- CUDA in Python verwenden -- Lernziele -- Teil II: Generative Adversarial Networks erstellen -- Kapitel 5: Das GAN-Konzept -- Bilder generieren -- Gegnerisches Training -- Ein GAN trainieren -- GANs sind schwer zu trainieren -- Lernziele -- Kapitel 6: Einfache 1010-Muster -- Echte Datenquelle -- Den Diskriminator erstellen -- Den Diskriminator testen -- Den Generator erstellen -- Die Generatorausgabe überprüfen -- Das GAN trainieren -- Lernziele -- Kapitel 7: Handgeschriebene Ziffern -- Die Datensatzklasse -- Der MNIST-Diskriminator -- Den Diskriminator testen -- MNIST-Generator -- Die Generatorausgabe testen -- Das GAN trainieren -- Mode Collapse -- Das GAN-Training verbessern -- Mit Startwerten experimentieren -- Lernziele -- Kapitel 8: Menschliche Gesichter -- Farbbilder -- Der CelebA-Datensatz -- Hierarchisches Datenformat -- Die Daten abrufen -- Die Daten inspizieren -- Die Datensatzklasse -- Der Diskriminator -- Den Diskriminator testen -- GPU-Beschleunigung -- Der Generator -- Die Generatorausgabe überprüfen -- Das GAN trainieren -- Lernziele , Teil III: Komplexere GANs -- Kapitel 9: Convolutional GANs -- Speicherbedarf -- Lokalisierte Bildmerkmale -- Faltungsfilter -- Kerngewichte lernen -- Merkmalshierarchie -- MNIST-CNN -- CelebA-CNN -- Eigene Experimente -- Lernziele -- Kapitel 10: Konditionierte GANs -- cGAN-Architektur -- Diskriminator -- Generator -- Trainingsschleife -- Bilder grafisch darstellen -- Ergebnisse für das konditionierte GAN -- Lernziele -- Fazit -- Anhänge -- Anhang A: MSE-Verlust -- Anhang B: GANs merken sich die Trainingsdaten nicht -- Anhang C: Beispiel 1: Faltung mit Schrittweite 1, keine Auffüllung -- Anhang D: Gradientenabstieg - für das Training von GANs geeignet? -- Anhang E: Der CelebA-Datensatz -- Index

Additional Edition: Print version: Rashid, Tariq GANs mit PyTorch selbst programmieren Heidelberg : o'Reilly,c2020 ISBN 9783960091479

Keywords: Electronic books.

URL: https://ebookcentral.proquest.com/lib/th-brandenburg/detail.action?docID=6349844

URL: https://static.onleihe.de/content/bookwire_nat/20200914/9783960103936/v9783960103936.pdf

URL: https://static.onleihe.de/images/bookwire_nat/20200914/9783960103936/tn9783960103936l.jpg

URL: https://voebb.onleihe.de/berlin/frontend/mediaInfo,51-0-1360332967-100-0-0-0-0-0-0-0.html

UID:

Format: 1 online resource (424 pages)

Edition: 1st ed.

ISBN: 9783428573066

Series Statement: Duncker and Humblot Reprints Series

Note: Intro -- Vorwort -- Inhaltsverzeichnis -- Einleitung. Die Einhegungen -- I. Die Bedeutung der Regierung Karls II. für die Landwirtschaft und die socialen Verhältnisse des Platten Landes. -- II. Die Entwicklung der englischen Landwirtschaft im 18. Jahrhundert -- III. Der Begriff der Einhegung -- IV. Die Einhegungen des 15. und 16. Jahrhunderts -- V. Die Einhegungen des 18. Jahrhunderts und die Bildung großer Pachthöfe -- VI. Die Preisveränderungen und die Einhegungen -- Erstes Kapitel: Die Entwicklung einer besitzlosen landwirtschaftlichen Arbeiterklasse -- I. Die Dorfgesellschaft im ersten Drittel des vorigen Jahrhunderts -- II. Die Auflösung der Dorfgesellschaft -- III. Die Lage der ländlichen Arbeiter -- IV. Die Beurteilung dieser Wandlungen durch hervorragende zeitgenössische Schriftsteller -- Zweites Kapitel: Überblick über die Entwicklung der ländlichen Arbeitsverfassung in England -- Drittes Kapitel: Der sittliche Rückgang der ländlichen Arbeiter -- I. Die Lage der englischen Landwirtschaft unter dem Einflusse der Getreidegesetze -- II. Die Veränderung der Arbeitsverfassung unter dem Einflusse der hohen Preise wie der Armengesetzgebung in England und größerer Intensität des Betriebs in den östlichen Grafschaften -- III. Die Lage der Arbeiter und die Feldgürten -- Viertes Kapitel: Die Zeit der Reformen -- Erste Abteilung: Vom Armengesetz bis zum Schulgesetz -- I. Die Wirkungen des Armengesetzes von 1834 -- II. Die Feldgärten -- III. Die Einführung des Freihandels -- IV. Die Lage der Arbeiter nach den offiziellen Berichten -- V. Die Reformen -- Zweite Abteilung: Gewerkvereine und Wiederbelebung des Bauernstandes -- I. Die Gewerkvereine ländlicher Arbeiter -- II. Die Wiederbelebung des Bauernstandes -- III. Die Lage der Landarbeiter im Anfang dieses Jahrzehnts -- Schluß. , Anhang I. Äußerungen englischer Schriftsteller des 16., 17. u. 18. Jahrhunderts über die wirtschaftliche und sociale Bedeutung der handarbeitenden Klassen für das Gemeinwesen -- Anhang II. Über den Begriff des „borderer -- Die Bestrebungen zur Sicherung des Kleingrundbesitzes in Dänemark. Von Professor Dr. William Scharling in Kopenhagen -- Die ländliche Arbeiterfrage in Schweden. Von Professor Dr. Pontus Fahlbeck in Lund.

Additional Edition: Print version: Hasbach, Wilhelm Die Englischen Landarbeiter in Den Letzten Hundert Jahren und Die Einhegungen Berlin : Duncker & Humblot,c2014 ISBN 9783428173068

Language: German

Keywords: Electronic books.

URL: Click to View

URL: lizenzpflichtig

UID:

Format: 1 online resource (396 pages)

ISBN: 9783969100257

Note: Intro -- Inhalt -- Danksagung -- Wie um alles in der Welt ist so etwas möglich? -- Über dieses Buch -- Bevor wir beginnen -- Teil 1: Von null auf Bilderkennung -- Kapitel 1: Einführung in Machine Learning -- Programmierung und Machine Learning im Vergleich -- Überwachtes Lernen -- Die Mathematik hinter dem Zaubertrick -- Das System einrichten -- Kapitel 2: Ihr erstes ML-Programm -- Die Aufgabenstellung -- Pizzavorhersage mit überwachtem Lernen -- Zusammenhänge in den Daten erkennen -- Eine lineare Regression programmieren -- Das Modell definieren -- Eine Vorhersage treffen -- Das Training implementieren -- Los geht's! -- Bias hinzufügen -- Zusammenfassung -- Praktische Übung: Die Lernrate optimieren -- Kapitel 3: Am Gradienten entlang -- Unser Algorithmus bringt es nicht -- Das Gradientenverfahren -- Ein wenig Mathematik -- Abwärts -- Die dritte Dimension -- Partielle Ableitung -- Die Probe aufs Exempel -- Probleme beim Gradientenverfahren -- Zusammenfassung -- Praktische Übung: Über das Ziel hinaus -- Kapitel 4: Hyperräume -- Noch mehr Dimensionen -- Matrizenrechnung -- Matrizen multiplizieren -- Matrizen transponieren -- Das ML-Programm erweitern -- Die Daten aufbereiten -- Die Vorhersagefunktion anpassen -- Die Verlustfunktion anpassen -- Die Gradientenfunktion anpassen -- Der Code im Ganzen -- Bye-bye, Bias! -- Ein letzter Testlauf -- Zusammenfassung -- Praktische Übung: Statistik in der Praxis -- Kapitel 5: Ein binärer Klassifizierer -- Grenzen der linearen Regression -- Invasion der Sigmoiden -- Konfidenz -- Glätten -- Den Gradienten anpassen -- Was ist mit der Modellfunktion geschehen? -- Klassifizierung in Aktion -- Zusammenfassung -- Praktische Übung: Gewichtige Entscheidungen -- Kapitel 6: Eine Aufgabe aus der Praxis -- Die Daten -- MNIST -- Trainings- und Testdatensatz -- Unsere eigene MNIST-Bibliothek , Die Eingabematrizen vorbereiten -- Die Daten aufbereiten -- Anwendung in der Praxis -- Zusammenfassung -- Praktische Übung: Knifflige Ziffern -- Kapitel 7: Die große Herausforderung -- Von zwei zu mehr Klassen -- 1-aus-n-Codierung -- 1-aus-n-Codierung in Aktion -- Die Antworten des Klassifizierers decodieren -- Mehr Gewichte -- Die Matrixdimensionen überprüfen -- Der Augenblick der Wahrheit -- Zusammenfassung -- Praktische Übung: Minensucher -- Kapitel 8: Das Perzeptron -- Gestatten, das Perzeptron! -- Perzeptrone kombinieren -- Die Grenzen von Perzeptronen -- Linear separierbare Daten -- Nicht linear separierbare Daten -- Die Geschichte des Perzeptrons -- Der entscheidende Schlag -- Nachwehen -- Teil 2: Neuronale Netze -- Kapitel 9: Das Netz entwerfen -- Ein neuronales Netz aus Perzeptronen zusammenstellen -- Perzeptrone verketten -- Wie viele Knoten? -- Die Softmax-Funktion -- Der Entwurf -- Zusammenfassung -- Praktische Übung: Auf eigene Faust -- Kapitel 10: Das Netz erstellen -- Die Forward-Propagation programmieren -- Die Softmax-Funktion schreiben -- Die Klassifizierungsfunktionen schreiben -- Kreuzentropie -- Zusammenfassung -- Praktische Übung: Test durch Zeitreise -- Kapitel 11: Das Netz trainieren -- Wozu Backpropagation? -- Von der Kettenregel zur Backpropagation -- Die Kettenregel in einem einfachen Netz -- Es wird komplizierter -- Backpropagation anwenden -- Auf Kurs bleiben -- Den Gradienten von w2 berechnen -- Den Gradienten von w1 berechnen -- Die Funktion back() erstellen -- Die Gewichte initialisieren -- Gefährliche Symmetrie -- Tote Neuronen -- Korrekte Gewichtsinitialisierung -- Das fertige neuronale Netz -- Zusammenfassung -- Praktische Übung: Fehlstart -- Kapitel 12: Funktionsweise von Klassifizierern -- Eine Entscheidungsgrenze einzeichnen -- Heimspiel für das Perzeptron -- Klassifizierung verstehen , Eine Gerade reicht nicht aus -- Die Entscheidungsgrenze krümmen -- Zusammenfassung -- Praktische Übung: Albtraumdaten -- Kapitel 13: Das Mini-Batch-Verfahren -- Der Lernvorgang grafisch dargestellt -- Batch für Batch -- Batches erstellen -- Training mit Batches -- Was geschieht bei verschiedenen Batchgrößen? -- Ein Zickzackpfad -- Große und kleine Batches -- Vor- und Nachteile von Batches -- Zusammenfassung -- Praktische Übung: Das kleinste Batch -- Kapitel 14: Die Kunst des Testens -- Die Gefahr der Überanpassung -- Das Problem mit dem Testdatensatz -- Zusammenfassung -- Praktische Übung: Überlegungen zum Testen -- Kapitel 15: Entwicklung -- Daten aufbereiten -- Den Wertebereich der Eingabevariablen prüfen -- Eingabevariablen standardisieren -- Standardisierung in der Praxis -- Die Hyperparameter anpassen -- Die Anzahl der Epochen festlegen -- Die Anzahl der verdeckten Knoten einstellen -- Die Lernrate einstellen -- Die Batchgröße festlegen -- Der Abschlusstest -- Auf dem Weg zu 99 % -- Praktische Übung: 99 % erreichen -- Zusammenfassung und Vorschau -- Teil 3: Deep Learning -- Kapitel 16: Tiefere Netze -- Der Echidna-Datensatz -- Neuronale Netze mit Keras erstellen -- Den Aufbau des Netzes planen und der erste Code -- Die Daten laden -- Das Modell erstellen -- Das Modell kompilieren -- Das Netz trainieren -- Die Entscheidungsgrenze einzeichnen -- Das Netz ausführen -- Ein tieferes Netz -- Zusammenfassung -- Praktische Übung: Keras-Spielwiese -- Kapitel 17: Überanpassung vermeiden -- Was ist Überanpassung? -- Ursachen der Überanpassung -- Unteranpassung -- Das Modell regularisieren -- Eine Untersuchung unseres tiefen Netzes -- L1- und L2-Regularisierung -- Weitere Möglichkeiten zur Regularisierung -- Zusammenfassung -- Praktische Übung: Weitere Regularisierungstechniken -- Kapitel 18: Tiefe Netze zähmen -- Aktivierungsfunktionen , Wozu Aktivierungsfunktionen gut sind -- Die sigmoide Aktivierungsfunktion und ihre Auswirkungen -- Verschwindender Gradient -- Alternativen zur Sigmoidfunktion -- Gestatten, die ReLU-Aktivierungsfunktion -- Die richtige Funktion auswählen -- Weitere Techniken -- Bessere Gewichtsinitialisierung -- Gradientenabstieg auf Speed -- Regularisierung für Fortgeschrittene -- Batchnormalisierung -- Zusammenfassung -- Praktische Übung: Die 10-Epochen-Aufgabe -- Kapitel 19: Jenseits von Standardnetzen -- Der CIFAR-10-Datensatz -- Was ist CIFAR-10? -- Das CIFAR-Waterloo -- Die Bausteine von Faltungsnetzen -- Ein Bild ist ein Bild -- Faltung -- Konvolutionsschichten -- Ein Faltungsnetz ausführen -- Zusammenfassung -- Praktische Übung: Massenweise Hyperparameter -- Kapitel 20: Der Weg in die Tiefe -- Der Aufstieg des Deep Learning -- Es braut sich etwas zusammen -- Der Wendepunkt -- Fortsetzung folgt -- Unverhältnismäßige Effektivität -- Was nun? -- Maschinelles Sehen -- Sprache -- Bildgenerierung -- Das Gesamtbild -- Praktischer Einstieg -- Sie sind am Zug -- Anhang -- A: Grundlagen von Python -- Wie sieht Python-Code aus? -- Dynamische Typisierung -- Einrückungen -- Die Bausteine von Python -- Datentypen und Operatoren -- Datenstrukturen -- Strings -- Schleifen -- Funktionen definieren und aufrufen -- Schlüsselwortargumente -- Standardargumente -- Module und Pakete -- Module definieren und importieren -- Das __main__-Idiom -- Pakete verwalten -- Objekte erstellen und verwenden -- Das war's -- B: Wörterbuch des Machine Learning -- Stichwortverzeichnis

Additional Edition: Print version: Perrotta, Paolo Machine Learning für Softwareentwickler Heidelberg : dpunkt.verlag,c2020 ISBN 9783864907876

Keywords: Electronic books.

URL: https://ebookcentral.proquest.com/lib/th-brandenburg/detail.action?docID=6341803

URL: https://static.onleihe.de/content/bookwire_nat/20200908/9783969100257/v9783969100257.pdf

URL: https://static.onleihe.de/images/bookwire_nat/20200908/9783969100257/tn9783969100257l.jpg

URL: https://voebb.onleihe.de/berlin/frontend/mediaInfo,51-0-1358044666-100-0-0-0-0-0-0-0.html