IT-Berufe-Podcast

Der Ablauf des Bewerbungsverfahrens für Azubis zum Fachinformatiker Anwendungsentwicklung bzw. auf das duale Studium der Wirtschaftsinformatik ist das Thema der achzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Bei der Alte Oldenburger Krankenversicherung in Vechta begleite ich die Auswahl künftiger IT-Azubis durch vier Schritte: schriftliche Bewerbung, Vorstellungsgespräch, Einstellungstest und Vorstellungstag. Dabei zählen dein Interesse am Beruf und die Frage, wie gut du mit dem Team zusammenarbeitest; Schulnoten und Testergebnisse fließen ebenfalls ein. Programmieren lernst du während der Ausbildung, wobei erste Erfahrungen durch Praktika oder eigene Projekte helfen, den Beruf einzuschätzen. Für deine Bewerbung solltest du dich über den Ausbildungsberuf und das Unternehmen informieren, eigene Fragen vorbereiten und offen zeigen, wer du bist.

Kapitelmarken

[00:00:01] Thema der Episode

[00:00:20] Video und Präsentation zur Podcastfolge

[00:01:40] Das Bewerbungsverfahren bei der Alte Oldenburger

[00:02:31] Die vier Schritte im Überblick

[00:04:08] Schriftliche Bewerbung und E-Mail

[00:05:30] Interesse am Beruf und Schulnoten

[00:07:23] Mathematik als Anhaltspunkt

[00:08:50] Englisch in der Anwendungsentwicklung

[00:10:18] Verständlich auf Deutsch schreiben

[00:11:56] Informatikkurse und praktische Erfahrungen

[00:13:15] Aufgaben der verschiedenen IT-Berufe

[00:15:14] Auswahl für das Vorstellungsgespräch

[00:15:48] Ablauf des Gesprächs und erwartete Vorkenntnisse

[00:17:21] Persönlichkeit und Zusammenarbeit im Team

[00:18:52] Interesse am Beruf und lebenslanges Lernen

[00:20:34] Das Unternehmen kennenlernen

[00:22:42] Vergütung und Arbeitsalltag im Gespräch

[00:24:30] Rolle und Dauer des Einstellungstests

[00:27:04] Mathematikaufgaben im Test

[00:28:01] Englische Fachtexte verstehen

[00:29:25] Allgemeines IT-Wissen

[00:30:25] Programmieraufgaben und logisches Denken

[00:32:30] Einladung zum Vorstellungstag

[00:34:15] Rundgang und Feedback zum Test

[00:35:54] Gemeinsam Java-Aufgaben bearbeiten

[00:39:21] Gespräch mit aktuellen IT-Azubis

[00:41:20] Beruf und Ablauf der Ausbildung recherchieren

[00:43:16] Eigene Gründe für die Berufswahl erklären

[00:44:16] Informationen über das Unternehmen sammeln

[00:45:40] Eigene Fragen vorbereiten

[00:47:15] Die eigene Bewerbung kennen und mitbringen

[00:47:55] Pünktlich zum Gespräch erscheinen

[00:48:58] Smalltalk und Umgang mit anderen Personen

[00:49:53] Offen auftreten und du selbst bleiben

[00:50:47] Feedback und Shownotes

Inhalt

Falls du noch ganz am Anfang stehst, habe ich hier konkrete Tipps zur Bewerbung um eine Ausbildung als Anwendungsentwickler/in.

Schriftliche Bewerbungen

Aus den eingegangenen schriftlichen Bewerbungen sortieren wir zunächst die vielversprechendsten Kandidaten aus. Dabei schauen wir nicht allein auf die Zeugnisnoten, sondern insb. auch darauf, ob ein Interesse am angestrebten Beruf vorhanden ist. Viel wichtiger als perfekte Noten sind daher zum Beispiel Praktika in anderen Unternehmen mit Bezug zur Softwareentwicklung.

Aber natürlich sind auch die Noten interessant für uns. Dabei schauen wir vor allem auf die Noten in den Fächern Mathe, Deutsch und Englisch. Englisch, da fast alle wichtigen und interessanten Texte zur Programmierung auf Englisch vorliegen. Mathe, weil meiner Meinung nach ein gewisser Bezug zwischen der logischen Denkweise der Mathematik und der Programmierung besteht. Und Deutsch, weil es bei der Softwareentwicklung nicht nur um das Erzeugen von Code geht, sondern auch um die schriftliche Kommunikation z.B. mit Kunden und natürlich auch die Dokumentation von Anwendungen.

Interessant sind für uns auch immer mehrere Zeugnisse, um einen Trend erkennen zu können. Außerdem gibt es z.B. in der Mathematik ganz unterschiedliche Themenbereiche (z.B. Kurvendiskussion und Stochastik), die dem Bewerber leichter oder schwerer fallen, und eine einzelne Note ist dann wenig aussagekräftig. Sehr gut ist es natürlich auch, wenn die Kandidaten Kurse in Informatik belegt haben. Aber nicht, weil wir Vorwissen erwarten, sondern weil das (wie bereits oben erwähnt) ein gewisses Interesse am Beruf zeigt.

Vorstellungsgespräche

Die interessantesten Kandidaten laden wir zu einem Vorstellungsgespräch zu uns ein. Üblicherweise sprechen wir ca. eine halbe Stunde mit den Bewerbern. Das gestaltet sich als ein eher lockeres Gespräch. Wir machen keine Leistungsabfragen oder fragen Fachbegriffe ab. Vielmehr muss deutlich werden, dass der Bewerber ins Team passt, und ein gewisses Engagement und Initiative mitbringt. Er sollte einfach glaubhaft vermitteln, dass der Beruf des Anwendungsentwicklers der richtige für ihn ist.

Ein paar allgemeine Informationen setzen wir beim Bewerber allerdings auch voraus. So macht es einen sehr schlechten Eindruck, wenn der Kandidat nicht mehr weiß, auf welchen Beruf er sich beworben hat (ist leider schon vorgekommen) oder in welchem Unternehmen er eigentlich gerade sitzt. Das Geschäftsfeld und ein wenig über die Historie des Unternehmens sollten dem Bewerber also durchaus bekannt sein. Das Internet bietet zahlreiche Möglichkeiten, um sich darüber umfassend zu informieren.

Aber auch der potentielle Azubi soll natürlich über das Unternehmen informiert werden. So sind z.B. die Arbeitszeiten, die Ausbildungsvergütung und die Sozialleistungen sowie das Betriebsumfeld Themen des Gesprächs.

Einstellungstest

Nach dem Vorstellungsgespräch absolvieren die Bewerber dann einen ca. anderthalbstündigen schriftlichen Einstellungstest. Dabei geht es vor allem um die Bereiche Mathematik und Englisch, die jeder Bewerber aus der Schule kennen sollte. Außerdem werden auch ein paar allgemeine Fragen aus der IT gestellt, die auf ein allgemeines Interesse am Beruf schließen lassen, z.B. was HTTP ist oder welche Betriebssysteme es so gibt.

Einen separaten Bereich zum Thema Programmierung gibt es auch. Wir erwarten allerdings auf keinen Fall, dass unsere Bewerber schon programmieren können. Dennoch bieten viele Schulen inzwischen Programmierkurse an. Und falls Vorwissen vorhanden ist, gibt uns der Test einen kleinen Aufschluss über die vorhandenen Erfahrungen. Konkrete Programmieraufgaben gibt es allerdings nur sehr wenige. Vielmehr geht es um einfache logische Zusammenhänge, für die man nicht programmieren können muss.

Vorstellungstag

Die vielversprechendsten Kandidaten aus Vorstellungsgesprächen und Tests laden wir üblicherweise für einen halben Tag noch einmal zu uns ein. An diesem Nachmittag gehen wir z.B. einmal durch unser Bürogebäude, schauen uns den Serverraum an und besuchen die Kollegen aus der Abteilung, damit die Bewerber sich ein besseres Bild ihres zukünftigen Arbeitsplatzes machen können. Außerdem gehen wir den Einstellungstest des Kandidaten durch und geben ein Feedback zu den Ergebnissen.

Aber auch wir wollen natürlich einen guten Eindruck des Kandidaten bekommen, daher ist der Großteil des Tages für ein gemeinsames Programmieren reserviert. Dabei lösen wir zusammen kleine Programmieraufgaben, die ich so auch in den ersten Wochen der Ausbildung mit den zukünftigen Azubis bearbeiten würde. Auch hier geht es wieder einmal nicht darum, schon programmieren zu können, sondern darum, herauszufinden, ob zwischenmenschlich eine Zusammenarbeit zwischen Azubi und Ausbilder denkbar wäre, und ob ein gewisses Verständnis für die Programmierung vorhanden ist.

Außerdem bietet der Vorstellungstag die Gelegenheit, noch offene Fragen beider Seiten zu klären. Das beinhaltet bei uns auch ein Gespräch "unter vier Augen" mit den aktuellen Azubis des Unternehmens, die bestimmte Fragen sicherlich besser beantworten können, als der böse Ausbilder ;-) Am Ende dieses Tages sollen das Ausbildungsunternehmen und der potentielle Azubi ein gutes Bild von der zukünftigen Zusammenarbeit haben, sodass sowohl wir als auch der Bewerber diese wichtige Entscheidung für die nächsten drei Jahre treffen kann.

Tipps zur Vorbereitung auf das Bewerbungsverfahren

Informationen zum Berufsbild einholen (z.B. übliche Aufgaben, Tagesablauf).

Informationen zur Ausbildung einholen (z.B. Ort der Berufsschule, Dauer).

Argumentation für die eigene Berufswahl zurechtlegen (warum möchtest du Anwendungsentwickler werden?).

Informationen zum Unternehmen einholen (z.B. Geschäftsfeld, Größe, Historie).

Eigene Fragen an das Unternehmen vorbereiten (z.B. Vergütung, Ablauf der Ausbildung, Inhalte der Ausbildung).

Eigene Bewerbung mitnehmen (z.B. bei Fragen zu Zeugnisnoten oder Inhalten des Anschreibens).

Pünktlich erscheinen, aber auch nicht überpünktlich (10-15 Minuten vorher da sein reicht aus).

Ggfs. aktuelles Tagesgeschehen für Smalltalk verfolgen (z.B. Nachrichten).

Grundsätzlich: offen und ehrlich sein, nicht verstellen.

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Tipps zur Bewerbung um eine Ausbildung als Anwendungsentwickler/in

Ablauf des Bewerbungsverfahrens für Fachinformatiker Anwendungsentwicklung - YouTube

Ausbildungsvergütung: Welcher Azubi bekommt wie viel Gehalt? - SPIEGEL ONLINE

Hypertext Transfer Protocol – Wikipedia

Gerda Feldhaus als landesbeste Anwendungsentwicklerin Niedersachsens ausgezeichnet

Zusammenfassung

So läuft das Verfahren ab

Bei der Alte Oldenburger Krankenversicherung in Vechta begleite ich das Verfahren, mit dem künftige Fachinformatiker:innen für Anwendungsentwicklung ausgewählt werden. Die beschriebenen Abläufe stammen aus dem Verfahren für den Ausbildungsstart 2017. Andere Unternehmen gestalten ihre Auswahl anders und führen beispielsweise zusätzlich ein Assessment-Center durch.

Das Verfahren umfasst vier Schritte:

Die schriftlichen Bewerbungen werden gesichtet, bevor ausgewählte Bewerber:innen eine Einladung erhalten.

Ein Vorstellungsgespräch dauert etwa 30 Minuten.

Direkt anschließend folgt ein schriftlicher Einstellungstest mit 90 Minuten Zeit.

Zwei bis drei Bewerber:innen werden zu einem Vorstellungstag eingeladen, der etwa zwei bis vier Stunden dauert.

...

Eine Lernzielkontrolle zu Exceptions (in Java) gibt es in der neunundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Mit meiner Lernzielkontrolle zu Exceptions kannst du dein Wissen über Fehler beim Programmieren prüfen und dich auf Fragen im Fachgespräch vorbereiten. Eine Exception kennzeichnet eine Ausnahmesituation und unterbricht den normalen Programmfluss, bis ein passender catch-Block sie auffängt. An Java zeige ich dir, wie du Exceptions gezielt behandelst oder weiterreichst, was Checked Exceptions bedeuten und wie try-with-resources Ressourcen automatisch schließt. Der Stacktrace hilft dir, Fehler zu finden; weil sein Erzeugen Aufwand verursacht, gehören Exceptions in die Ausnahmebehandlung.

Kapitelmarken

[00:00:01] Hinweis zum Fachgespräch

[00:00:37] Lernzielkontrolle zu Exceptions mit Java

[00:02:38] Fragen fürs Fachgespräch und ergänzendes Hörbuch

[00:03:30] Was eine Exception ist

[00:05:03] Die Analogie vom Werfen und Fangen

[00:06:38] Exceptions behandeln oder weiterreichen

[00:08:38] Die passende Stelle für den Umgang mit Fehlern

[00:10:49] Exceptions mit try und catch auffangen

[00:12:30] finally und das Schließen von Ressourcen

[00:15:39] try-with-resources und AutoCloseable

[00:17:13] Exceptions mit throw auslösen

[00:19:53] throws und Checked Exceptions

[00:22:10] Mehrere Exception-Typen gezielt auffangen

[00:23:36] Unchecked Exceptions

[00:25:46] Eigene Exception-Klassen und zusätzliche Attribute

[00:27:54] Call-Stack und Stacktrace bei der Fehlersuche

[00:30:38] Aufwand von Exceptions und regulärer Programmablauf

[00:32:08] Die Java-Hierarchie mit Throwable, Error und Exception

[00:35:08] Was Exceptions beim Umgang mit Fehlern ermöglichen

[00:37:42] Prüfungsbezug und Quellen zum Vertiefen

[00:39:50] Hörbuch-Tipp: What If von Randall Munroe

[00:41:20] Ausblick auf weitere Lernzielkontrollen

Inhalt

Exceptions

Was ist eine "Exception"?

Eine unerwartete Ausnahmesituation in einem Programm, meistens ein Fehler.

Oder: Die Klasse, die dieses Konzept in der Programmiersprache repräsentiert.

Was ist die Analogie zur Erklärung der Behandlung von Exceptions?

Man "wirft" und "fängt" Exceptions wie einen Ball.

Wie kann man grundsätzlich mit Exceptions umgehen?

Man kann sie entweder direkt fangen (und das Problem lösen) oder dies an den Aufrufer delegieren (weiterwerfen).

Wie behandelt man eine Exception in Java?

Mittels try, catch und finally.

Wann braucht man einen finally-Block?

Wenn eine Operation unter allen Umständen nach try/catch ausgeführt werden muss (insb. wenn im catch-Block potentiell auch Fehler auftreten können).

Was ist try-with-resources?

Ein Sprachkonstrukt in Java, das dafür sorgt, dass Ressourcen nach ihrer Nutzung sauber wieder geschlossen werden, egal ob eine Exception auftritt oder nicht. Die Ressource muss dafür java.lang.AutoCloseable implementieren. Entspricht using in .NET.

Was macht das Schlüsselwort throw?

Wirft eine Exception.

Was macht das Schlüsselwort throws?

Markiert eine Methode als potentiell fehleranfällig und zwingt den Aufrufer zur Fehlerbehandlung.

Was ist der Unterschied zwischen "checked" und "unchecked" Exceptions?

Checked Exceptions (die es nur in Java gibt), müssen behandelt werden (der Compiler prüft das). Unchecked Exceptions (z.B. nicht vorhersehbare Laufzeitfehler wie "Speicher voll") müssen nicht behandelt werden.

Wie erzeugt man seine eigenen Exceptions?

Man kann eigene Klassen von Exception erben lassen. Diese können dann auch "echte" Attribute und Methoden beinhalten.

Was ist der "Call Stack"?

Der Aufrufstack enthält die Rücksprungadressen aller im bisherigen Programmablauf aufgerufenen Methoden. Darüber kann man nachvollziehen, wie das Programm zur aktuellen Position gelangt ist. Jede Exception hat den Call Stack bis zu ihrem Auftreten als Attribut.

Sollte man Exceptions zur Steuerung des Programmablaufs einsetzen?

Nein, da Exceptions - z.B. wegen des Call Stacks - recht "teuer" sind.

Wie sieht die Hierarchie von Exceptions in Java grob aus?

Throwable: Basisklasse aller Exceptions in Java.

Error: "Echte" Fehler, die ein Programm normalerweise nicht behandeln kann (z.B. StackOverflowError).

Exception: Fehler, die das Programm behandeln können sollte.

RuntimeException: Unchecked Exceptions wie z.B. ArithmeticException bei Division durch 0.

Was sind die Vorteile von Exceptions gegenüber direkter Fehlerbehandlung?

Produktivcode und Fehlerbehandlungscode werden stärker getrennt.

Man kann das Behandeln von Fehlern an den Aufrufer delegieren.

Man kann einfacher zwischen verschiedenen Fehlern unterscheiden.

Literaturempfehlungen

Die Java-Insel* beschreibt in einem eigenen Kapitel ausführlich den Umgang mit Exceptions in Java (siehe Exceptions).

*(direkt beim Rheinwerk-Verlag bestellen*)

Und auch Clean Code* enthält ein komplettes Kapitel zum Umgang mit Exceptions und Fehlersituationen.

*

Meine Hörbuch-Empfehlung der Woche: What if?* von Randall Munroe

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Lesson: Exceptions (The Java Tutorials - Essential Classes)

The try-with-resources Statement (The Java Tutorials - Essential Classes - Exceptions)

Call stack - Wikipedia, the free encyclopedia

Exception Hierarchy in Java

The Truth Behind the Big Exceptions Lie | Java Code Geeks - 2016

Zusammenfassung

Exceptions als Thema für IT-Azubis

Für meine IT-Azubis ergänze ich die Aufgaben aus dem Java-Tutorial mit Lernzielkontrollen. Die Fragen zu Exceptions eignen sich auch, wenn du dich als Fachinformatiker:in Anwendungsentwicklung auf dein Fachgespräch vorbereitest. Fehler beim Programmieren zu behandeln, ist ein allgemeines Thema; die technischen Details beziehen sich hier auf Java. Auch C# und Ruby kennen Exceptions.

Was eine Exception bedeutet

Wenn während eines Programmlaufs eine unerwartete Situation auftritt, spricht man von einer Exception, also einer Ausnahme. Der Begriff bezeichnet außerdem die Klasse beziehungsweise das Objekt, das diese Situation im Programm repräsentiert. Eine Ausnahme kann durch einen Fehler entstehen oder durch ein Verhalten, das vom erwarteten Ablauf abweicht.

Beim Umgang mit Exceptions hilft das Bild eines Balls: Ich werfe eine Exception, die an einer passenden Stelle aufgefangen wird. Dazu passen die Schlüsselwörter throw und catch.

Exceptions auffangen und weiterreichen

Du kannst eine Exception dort auffangen, wo dein Code sinnvoll auf sie reagieren kann. Wenn sich die Datenbank vorübergehend nicht erreichen lässt, kann ich beispielsweise fünf Sekunden warten und erneut versuchen, mich zu verbinden. Nach einem erfolgreichen Versuch läuft das Programm weiter.

Bleibt die Datenbank unerreichbar, reicht die Methode den Fehler an die aufrufende Methode weiter. Eine grafische Oberfläche kann daraufhin der/dem Benutzer:in eine verständliche Meldung anzeigen.

Exceptions wandern automatisch durch den Call-Stack, bis ein passender Block sie auffängt. Dadurch kannst du die Stelle, an der ein Fehler entsteht, von der Stelle trennen, an der dein Code darauf reagiert. Entscheidend ist, welche Methode mit der konkreten Situation umgehen kann.

Ein zentraler catch-Block in der main-Methode kann Exceptions auffangen, die bis dorthin gelangen. Ich empfehle, Fehler gezielt an einer geeigneten Stelle zu behandeln, weil beim Auffangen in main häufig nur noch das Beenden des Programms bleibt.

Wie try, catch und finally arbeiten

In einem try-Block steht Code, bei dem eine Exception auftreten kann. Für eine Datenbankabfrage würde ich dort die entsprechenden Aufrufe unterbringen.

Sobald eine Exception auftritt, wird der normale Ablauf an dieser Stelle unterbrochen. Das Programm sucht einen passenden catch-Block und führt dessen Code aus. Wenn der try-Block erfolgreich durchläuft, wird der catch-Block übersprungen. Eine unbehandelte Exception kann zum Programmabbruch führen und auf der Konsole ausgegeben werden.

Der optionale finally-Block wird beim Verlassen dieser Struktur ausgeführt, auch wenn während des Ablaufs oder im catch-Block eine Exception auftritt. Dort kann ich Ressourcen schließen, die nach dem Zugriff wieder freigegeben werden müssen. Das betrifft beispielsweise eine geöffnete Datenbankverbindung.

Auch beim Schließen einer Verbindung kann eine weitere Exception entstehen. Code, der erst hinter der gesamten try-catch-Struktur steht, wird in einem solchen Fall möglicherweise übersprungen. Für Aufräumarbeiten ist deshalb der finally-Block vorgesehen.

Ressourcen automatisch schließen

Wenn ich mit Ressourcen arbeite, verwende ich in Java try-with-resources. Die Ressource wird in den Klammern hinter try angegeben und am Ende automatisch geschlossen, auch wenn eine Exception auftritt.

Das eignet sich etwa für Datenbankverbindungen und Dateihandles. Voraussetzung ist, dass die Ressource das Interface java.lang.AutoCloseable implementiert. In C# gibt es mit dem using-Block eine entsprechende Möglichkeit.

Mit throw eine Exception auslösen

Durch throw löst du selbst eine Exception aus. Dahinter steht das Objekt, das geworfen wird, beispielsweise eine neu erzeugte Instanz einer Exception-Klasse.

Ich gebe einer Exception eine aussagekräftige Fehlermeldung und wähle einen passenden Typ. Eine DatabaseNotAvailableException macht erkennbar, dass die Datenbank fehlt. Ein darauf abgestimmter catch-Block kann gezielt auf diesen Fehler reagieren.

throws und Checked Exceptions

Mit throws gibst du an einer Java-Methode an, welche Exceptions beim Aufrufen auftreten können. Mehrere Typen lassen sich dort ebenfalls aufführen.

Bei Checked Exceptions prüft der Compiler, ob die aufrufende Methode mit den möglichen Fehlern umgeht. Dafür gibt es zwei Wege:

Du fängst die Exception mit einem passenden catch-Block auf.

Du reichst sie weiter und führst sie im throws-Teil der aufrufenden Methode auf.

Der Compiler weist dadurch auf fehlende Schritte beim Umgang mit diesen Exceptions hin. Wenn ich sie durch viele Methoden weiterreiche,...

Um Kapitel 13 (Datenbanken) des Handbuchs für Fachinformatiker geht es in der achtundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Im elften Teil meines Buchclubs zum Handbuch für Fachinformatiker steht das Datenbankkapitel im Mittelpunkt. Für dich als IT-Azubi gehören relationale Datenbanken mit ihren Tabellenmodellen ebenso zum Prüfungsstoff wie SQL, besonders SELECT-Abfragen und JOINs. Die ersten drei Normalformen sowie Transaktionen mit den ACID-Prinzipien solltest du anhand von Beispielen erklären können. Das Handbuch bietet einen Einstieg, den du durch Fachliteratur und Aufgaben vertiefen solltest; auch NoSQL gehört zum Wissen für die Praxis.

Kapitelmarken

[00:00:01] Einstieg in den Buchclub: Datenbanken und Prüfungsbezug

[00:01:49] Vorlage für die Projektdokumentation mit LibreOffice

[00:04:29] Datenbankgrundlagen und Fachbegriffe

[00:05:13] Datenbanktypen und NoSQL im Handbuch

[00:06:36] Relationale Datenbanken und Tabellenmodelle

[00:08:43] Normalformen und ihre Bedeutung für die Prüfung

[00:10:08] Transaktionen und ACID-Prinzipien

[00:10:39] Objektorientierte Datenbanken und fünf NoSQL-Typen

[00:12:28] MySQL installieren und produktspezifisches Wissen

[00:14:01] MariaDB als MySQL-Fork

[00:14:52] SQL und DDL: Tabellen anlegen und verändern

[00:15:53] SELECT-Abfragen und JOINs

[00:17:06] INSERT, UPDATE, DELETE und Transaktionen

[00:17:44] MySQL-Administration und übertragbare SQL-Befehle

[00:19:13] Datenbankprogrammierung mit JDBC

[00:20:00] CouchDB und dokumentenorientierte Datenbanken

[00:20:50] Buchempfehlung: Seven Databases in Seven Weeks

[00:22:14] Ergänzende Podcastfolgen und Shownotes

[00:23:02] Hörbücher mit Audible

[00:24:45] Deep Work und konzentriertes Arbeiten

[00:27:12] Schulhunde-Blog und Fotografie

[00:28:13] Rabattcodes für die Dokumentationsvorlagen

[00:29:22] Ausklang und Verabschiedung

Inhalt

Kapitel 13 (Datenbanken)

Die verschiedenen Datenbanktypen

Absolutes Grundlagenwissen, das jeder ITler für die Prüfung - aber auch für die Praxis - drauf haben muss!

Normalformen (bis zur 3.) muss man in- und auswendig kennen und gut erklären können. Am besten mit Beispielen.

NoSQL kommt mir zu kurz und sollte definitiv mit weiterer Literatur gelernt werden.

MySQL – ein konkretes RDBMS

Produktspezifika sind für die IHK-Prüfung irrelevant und veralten recht schnell in der Praxis. MySQL selbst ist eigentlich schon durch MariaDB abgelöst.

SQL-Abfragen

Eine Kernkompetenz für jeden Entwickler! Und mit absoluter Regelmäßigkeit ein zentrales Thema in jeder (!) IHK-Prüfung. Häufig sogar in GH2.

Für den Einstieg gut geeignet, aber nicht ausreichend für die Prüfungsvorbereitung.

MySQL-Administration

s.o.

Grundlagen der Datenbankprogrammierung

Eine (sehr) kurze Einführung in die Datenbankprogrammierung mit JDBC. Nett zu wissen, aber für die Praxis nicht ausreichend und für die Prüfung irrelevant.

Die Kurzeinführung in CouchDB auf einer Seite reicht auch bei Weitem nicht aus, um sich Wissen für die Prüfung anzueignen.

Literaturempfehlungen

*(direkt beim Rheinwerk-Verlag bestellen*)

*

Meine Hörbuch-Empfehlung der Woche: Deep Work: Rules for Focused Success in a Distracted World von Cal Newport bei Amazon (Affiliate)*

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Relationale Datenbanken - Häufige Fragen im Fachgespräch - Anwendungsentwickler-Podcast #17

SQL - Häufige Fragen im Fachgespräch - Anwendungsentwickler-Podcast #19

Datenbankmodellierung (Lernzielkontrolle zum Entity-Relationship-Modell) – Anwendungsentwickler-Podcast #48

Datenbankmodellierung (Lernzielkontrolle zum relationalen Tabellenmodell) – Anwendungsentwickler-Podcast #49

Wie funktioniert eigentlich eine relationale Datenbank?

MariaDB – Wikipedia

Zusammenfassung

Datenbanken in der IT-Ausbildung

Für den elften Teil meines Buchclubs zum Handbuch für Fachinformatiker von Sascha Kersten nehme ich Kapitel 13 zu Datenbanken durch. Die Aussagen zu Prüfungen und Produkten beziehen sich auf den Stand von Oktober 2016.

Als IT-Azubi begegnet dir das Thema in schriftlichen Prüfungen ebenso wie im Fachgespräch und bei deiner Projektarbeit. Auch im damaligen gemeinsamen Prüfungsteil für die IT-Berufe kommen SQL-Aufgaben und gelegentlich Aufgaben zum Datenmodell vor.

Grundlagen und relationale Datenbanken

Du solltest erklären können, was eine Datenbank ist und welche Vorteile sie gegenüber einer Textdatei bietet. Zum Grundwissen gehören außerdem die Begriffe Stammdaten und Bewegungsdaten. Das Handbuch beschreibt sie kurz.

Im Buch führt eine Einzeltabellendatenbank, etwa eine Excel-Tabelle, zu den relationalen Datenbanken hin. Für deine Prüfung solltest du folgende Inhalte beherrschen:

Ein ER-Modell beschreibt ein Datenmodell auf einer abstrakten Ebene. Daraus lässt sich ein Tabellenmodell ableiten.

Zum Tabellenmodell gehören Relationen sowie Primär- und Fremdschlüssel.

Beziehungen können als 1:1, 1:n oder m:n vorliegen. Eine m:n-Beziehung wird im relationalen Modell über eine Zuordnungstabelle abgebildet.

Auf Grundlage der Tabellen kannst du mit SQL Daten abfragen.

Die Beispiele im Handbuch helfen dir, Tabellen und ihre Beziehungen zu verstehen. Zum Vertiefen empfehle ich weitere Quellen, weil diese Grundlagen häufig in Prüfungen vorkommen.

Normalformen und Transaktionen

Die erste bis dritte Normalform solltest du erklären und anhand von Beispielen zeigen können. Sie sind für die Praxis relevant und werden in mündlichen Prüfungen häufig abgefragt.

Das Buch behandelt außerdem die Boyce-Codd-Normalform sowie die vierte und fünfte Normalform. In meinen bisherigen schriftlichen Prüfungen kamen die höheren Normalformen nicht vor. Im Fachgespräch kannst du damit zusätzliches Wissen zeigen; auch bei Datenmodellen im Arbeitsalltag können sie dir weiterhelfen.

Bei Transaktionen und den ACID-Prinzipien brauchst du ebenfalls ein Verständnis, das über die kurzen Abschnitte im Handbuch hinausgeht. Du solltest jeden Bestandteil von ACID anhand eines Beispiels erklären können und wissen, welche Folgen es hat, wenn eine Eigenschaft verletzt wird. Das Buch greift die Prinzipien später im SQL-Teil erneut auf, behandelt sie insgesamt aber knapp.

NoSQL und objektorientierte Datenbanken

Das Handbuch konzentriert sich auf relationale Datenbanken. Für NoSQL empfehle ich ergänzende Fachliteratur, da diese Datenbanken auch in der Praxis eingesetzt werden.

Zu den NoSQL-Typen zähle ich hier:

objektorientierte Datenbanken,

spaltenorientierte Datenbanken,

dokumentenorientierte Datenbanken beziehungsweise Document Stores,

Key-Value-Datenbanken,

Graphdatenbanken.

Du solltest ihren Aufbau und ihre Funktionsweise grob erklären können, einschließlich ihrer Vor- und Nachteile. Wenn du NoSQL in deiner Projektdokumentation erwähnst, etwa bei der Wahl eines Datenbanksystems, musst du deine Aussagen im Fachgespräch erläutern können.

Objektorientierte Datenbanken erhalten im Handbuch vergleichsweise viel Raum. Für die Prüfung lege ich den Schwerpunkt auf relationale Datenbanken.

SQL für die Prüfung

Tabellen anlegen und verändern

Mit der Data Definition Language, kurz DDL, legst du Tabellenstrukturen fest oder änderst sie. Das Handbuch zeigt dazu Befehle wie CREATE TABLE und ALTER TABLE; mit DROP TABLE entfernst du eine Tabelle. Es stellt außerdem Datentypen und Beispiele für die Syntax vor.

Daten mit SELECT abfragen

Nach meiner Erfahrung machen SELECT-Abfragen den größten Teil der SQL-Prüfungsaufgaben aus. Im Buch findest du dazu unter anderem:

DISTINCT,

Bedingungen mit WHERE und OR,

Aggregatfunktionen,

JOINs, einschließlich INNER JOIN und OUTER JOIN.

Da Prüfungsaufgaben häufig mehrere Tabellen einbeziehen, solltest du JOINs gezielt üben. Für eine gründliche Vorbereitung empfehle ich zusätzliche Literatur und praktische Aufgaben.

Daten schreiben und Rechte vergeben

Mit INSERT fügst du Datensätze ein. UPDATE verändert vorhandene Daten, während DELETE Datensätze löscht. Auch diese Befehle gehören zum Prüfungsstoff.

Das Kapitel zur MySQL-Administration enthält zudem GRANT-Statements. Diese SQL-Befehle lassen sich auf andere Systeme übertragen und sind als allgemeines SQL-Wissen interessant.

MySQL, MariaDB und JDBC

Die Abschnitte zu MySQL zeigen, wie du das System unter Linux oder Windows installierst. Weitere Seiten behandeln Benutzer:innen und deren Rechte sowie den Import und Export von Daten. Auch Konfigurations- und Logdateien kommen vor. Diese Inhalte helfen dir beim praktischen Betrieb eines Systems.

Für die Prüfung stehen allgemeine Konzepte im Vordergrund. Produktspezifische Einstellungen und Abläufe ordne ich hier als Stoff für die Praxis ein.

Im Unternehmen arbeite ich zum Zeitpunkt der Aufnahme mit MariaDB, einem Fork von MySQL. Nach meiner damaligen Erfahrung lassen sich die beschriebenen MySQL-Konfigurationen auch für MariaDB übernehmen.

Der kurze Abschnitt zur Datenbankprogrammierung führt in JDBC, Java Database Connectivity, ein. Wenn du mit Java entwickelst, solltest du wissen, wie du damit auf eine Datenbank zugreifst. Die wenigen Seiten im Handbuch erfordern ergänzende Literatur, um das Thema gründlich zu lernen.

Bücher und ergänzende Materialien

CouchDB wird auf weniger als einer Seite als dokumentenorientierte Datenbank vorgestellt. Als weiteren bekannten Vertreter nennt das Kapitel MongoDB.

Für einen breiteren Überblick empfehle ich dir Seven Databases in Seven Weeks. Das Buch verbindet Theorie mit praktischen Beispielen und behandelt relationale Datenbanken sowie NoSQL-Konzepte. Aus derselben Buchreihe empfehle ich auch Seven Languages in Seven Weeks.

Meine ergänzenden Folgen zu ER-Modellen und Tabellenmodellen sowie zu SQL findest du in den Shownotes der Episode 78 unter anwendungsentwicklerpodcast.de. Dort stehen auch Links zu Artikeln und den erwähnten Büchern.

Weitere Hinweise aus der Episode

Unter dieperfekteprojektdokumentation.de biete ich meine Vorlage für die Projektdokumentation als Paket für Word und LibreOffice an. Die ODT-Version habe ich mit LibreOffice erstellt und dessen Funkt

Die noch offenen Fragen zur Versionsverwaltung mit Git sind der Inhalt der siebenundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Vor jedem Commit prüfe ich mit git status und git diff, welche Dateien und Inhalte sich geändert haben. Über den Index wählst du aus, was in deinen nächsten Commit kommt, dessen Nachricht den fachlichen Grund beschreibt. Mit den passenden Git-Befehlen kannst du Commits übertragen und ältere Stände anschauen; Branches und Tags helfen dir dabei, parallel zu entwickeln und bestimmte Versionen wiederzufinden. Für die Arbeit in deinem Ausbildungsbetrieb klärst du außerdem, welche Repositories du bearbeiten darfst und welche Regeln für Commit-Nachrichten sowie Branches gelten.

Kapitelmarken

[00:00:20] Einstieg und Rückblick auf Commits

[00:01:10] Änderungen mit git diff und git status prüfen

[00:04:25] Arbeitskopie, Index und Repository

[00:05:40] Änderungen auswählen und kleine Commits erstellen

[00:07:09] Änderungen mit git add aufnehmen und committen

[00:08:04] Commit-Nachrichten eingeben und fachlich begründen

[00:10:34] Den letzten Commit mit amend korrigieren

[00:11:45] Commits mit git push übertragen

[00:12:46] Vor dem Push Änderungen mit git pull holen

[00:14:33] Die Historie mit git log anschauen

[00:15:24] Ältere Commits auschecken und die Arbeitskopie vorbereiten

[00:18:21] Commits über ihren Hash auswählen

[00:19:27] Branches und parallele Entwicklung

[00:22:04] Entwicklungszweige durch einen Merge zusammenführen

[00:23:18] Automatische Merges und manuelle Konfliktlösung

[00:25:28] Der Hauptzweig master

[00:26:03] Versionen mit Tags benennen

[00:28:23] Fragen für deinen Ausbildungsbetrieb

[00:29:11] Einsatzgebiete der Versionsverwaltung im Betrieb

[00:29:56] Git am eigenen Arbeitsplatz einrichten

[00:30:46] Repositories finden und Zugriffsrechte klären

[00:31:53] Betriebliche Regeln für Commit-Nachrichten

[00:32:52] Branching-Strategie und Namen der Branches klären

[00:33:46] Git praktisch kennenlernen und weiterlernen

[00:34:53] Shownotes und Fragen als Markdown-Datei

Inhalt

Allgemeine Fragen

Welche Befehle musst du ausführen, um dir die aktuellen Änderungen in deiner Arbeitskopie anzuschauen?

Welche Befehle musst du ausführen, um deine Änderungen zu "committen"?

Was ist der Index?

Wie ist eine sinnvolle Commit-Nachricht aufgebaut?

Welche Befehle musst du ausführen, um Inhalte im letzten Commit zu korrigieren/ergänzen?

Welche Befehle musst du ausführen, um deine eigenen Commits in ein entferntes Repository zu übertragen?

Welche Befehle musst du ausführen, um den Inhalt deiner Arbeitskopie auf einen alten Commit zurückzusetzen?

Welche Befehle musst du ausführen, um dir die Commit-Historie eines Repositorys anzuschauen?

Was ist ein Branch?

Was ist ein Merge?

Wie heißt der Standard-Branch in Git? Wie in SVN?

Was ist ein Tag?

Fragen zum Ausbildungsbetrieb

Wofür setzt dein Unternehmen Git/SVN ein?

Was musst du tun, um Git an deinem eigenen Arbeitsplatz nutzen zu können?

Wo kannst du dir die Repositorys deines Unternehmens anschauen?

Welche besonderen Regeln für Commit-Nachrichten gibt es bei deinem Unternehmen?

Welche Branching-Strategie verfolgt dein Unternehmen?

Literaturempfehlungen

Git Tutorial – The Ultimate Guide (Julen Pardo)

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Wie man eine gute Git-Commit-Nachricht schreibt

Ein sinnvoller Git-Workflow

Zusammenfassung

Änderungen vor dem Commit prüfen

Vor meinen Commits führe ich git status und anschließend git diff aus. Damit kontrolliere ich, ob die vorgesehenen Dateien und Inhalte zum nächsten Commit gehören.

git status zeigt dir, welche Dateien sich geändert haben.

git diff zeigt die Unterschiede zeilenweise mit etwas Kontext. Farblich hervorgehobene Stellen helfen dir, hinzugefügte oder entfernte Inhalte zu erkennen. Dabei kannst du auch Schreibfehler und falsche Einrückungen entdecken.

Ein Commit hält einen Versionsstand fest. Dazu gehören die betroffenen Dateien sowie Metadaten, etwa die Nachricht, das Datum und der/die Autor:in.

Über den Index festlegen, was du committest

Wenn du Dateien in deiner Arbeitskopie bearbeitest, kannst du die gewünschten Inhalte anschließend in den Index, auch Stage genannt, aufnehmen. git commit erstellt daraus einen Commit im lokalen Repository.

Du kannst ganze Dateien oder einzelne geänderte Zeilen auswählen. Hast du in einer Datei an mehreren Features gearbeitet, lässt sich dadurch für jedes Feature ein eigener Commit erstellen.

Kleine, fachlich zusammenhängende Commits lassen sich leichter beschreiben. Auch beim späteren Merge mit den Änderungen anderer Entwickler:innen bleiben sie überschaubar.

Für den gezeigten Ablauf verwendest du:

bash

git add . --all

git commit

Mit git add . --all übernimmst du die Änderungen im aktuellen Verzeichnis in den Index, einschließlich gelöschter Dateien. Danach erstellt git commit den Commit und öffnet einen Texteditor für die Commit-Nachricht.

Wenn du die Nachricht direkt auf der Kommandozeile eingeben möchtest, verwendest du:

bash

git commit -m "Deine Commit-Nachricht"

Den fachlichen Grund in die Commit-Nachricht schreiben

In deiner Commit-Nachricht hältst du fest, warum du etwas geändert hast. Das kann eine geänderte Anforderung aus dem Fachbereich sein oder ein Fehler, den du beheben musstest.

Git speichert bereits, welche Inhalte geändert wurden und wer sie wann bearbeitet hat. Durch deine Nachricht wird auch der Anlass nachvollziehbar, sodass dein:e Kolleg:in den Commit später einordnen kann.

Weitere Regeln zum Aufbau und zur Formulierung von Commit-Nachrichten sind in meinen Shownotes verlinkt.

Den letzten Commit korrigieren

Wenn dir unmittelbar nach einem Commit ein Fehler auffällt und du ihn noch nicht an das entfernte Repository übertragen hast, kannst du ihn mit folgendem Befehl bearbeiten:

bash

git commit --amend

Damit lässt sich beispielsweise ein Tippfehler in der Commit-Nachricht korrigieren. Auch der Inhalt des letzten Commits kann angepasst werden. Für das beschriebene Vorgehen befindet sich deine Arbeitskopie zunächst auf dem Stand dieses Commits.

Commits an das Remote Repository übertragen

Mit git push überträgst du deine lokalen Commits an ein entferntes Repository. Git kann mit mehreren Remote Repositories arbeiten. Als ausdrücklich angegebenes Ziel wird hier folgendes Beispiel verwendet:

bash

git push origin master

Bei passend konfiguriertem Git reicht git push aus.

Wenn ein:e Kolleg:in zwischenzeitlich neue Commits übertragen hat, musst du diese zunächst lokal übernehmen. Git kann deinen Push sonst ablehnen, weil dir Änderungen aus dem Remote Repository fehlen.

Ich führe deshalb vor jedem Push einen Pull aus:

bash

git pull

git push

Dafür habe ich mir den eigenen Alias git pp eingerichtet, der beide Schritte nacheinander ausführt. Eigene Aliase werden in einer Konfigurationsdatei hinterlegt.

Die Historie und ältere Stände anschauen

Über git log kannst du die Commit-Historie durchgehen. Die neuesten Commits stehen oben. Du findest dort Angaben zu den Autor:innen und zum Zeitpunkt sowie die Commit-Nachrichten.

Möchtest du einen früheren Stand anschauen oder darin etwas ausprobieren, kannst du dessen Hash aus der Log-Ausgabe übernehmen:

bash

git checkout

Git holt die Dateien dieses Commits aus deinem lokalen Repository in die Arbeitskopie. Ein eindeutig zuordenbarer Anfang des Hashes reicht dafür aus; häufig genügen sechs bis sieben Zeichen.

Für diesen Ablauf brauchst du eine saubere Arbeitskopie, in der deine Änderungen bereits committet sind. Wenn beim Wechsel noch offene Änderungen verloren gehen würden, verweigert Git viele entsprechende Befehle. Mit git checkout kannst du auch wieder einen neueren Commit auswählen.

In Branches parallel entwickeln

Wenn du ein Feature getrennt vom Hauptentwicklungszweig ausprobieren möchtest, kannst du dafür einen Branch anlegen. Darin entstehen eigene Commits, während der Hauptzweig weiterentwickelt werden kann. Später kannst du das Feature übernehmen oder verwerfen.

Branches sind in Git leichtgewichtig, weil sie als Zeiger auf Commits dienen. Das Anlegen und Wechseln geht dadurch schnell. Eine mögliche Arbeitsweise besteht darin, für jedes Feature einen eigenen Branch zu erstellen.

Der Hauptzweig trägt im beschriebenen Ablauf den Namen master. Bei Subversion heißt der entsprechende Stamm trunk.

Branches zusammenführen und Konflikte lösen

Durch einen Merge führst du Entwicklungszweige zusammen. Der beschriebene Merge-Commit hat zwei Parent-Commits, sodass beide Entwicklungswege in der Historie verbunden bleiben.

Git kann viele Änderungen automatisch zusammenführen. Das gilt beispielsweise, wenn unterschiedliche Dateien bearbeitet wurden oder wenn Änderungen verschiedene Stellen derselben Datei betreffen.

Haben zwei Entwickler:innen dieselbe Zeile unterschiedlich geändert, kann ein Konflikt entstehen. Dann entscheidest du, welchen Inhalt die Datei erhalten soll. Dafür kann auch eine neue gemeinsame Lösung erforderlich sein.

Versionen mit Tags benennen

Für eine veröffentlichte Version kannst du dem zugehörigen Commit einen Tag geben, etwa v1.0. Dieser Name verweist auf einen bestimmten Stand und erleichtert dir, ihn später wiederzufinden.

bash

git tag v1.0

git checkout v1.0

Der Tag-Name lässt sich beim Checkout als Verweis auf die gewünschte Version angeben. Tags können auch in der Log-Ausgabe erscheinen.

Fünf Fragen für deinen Ausbildungsbetrieb

Diese Fragen habe ich meinem IT-Azubi mitgegeben, damit er die betrieblichen Abläufe mit Kolleg:innen klärt. Die Antworten bekommst du direkt in deinem Ausbildungsbetrieb.

Wofür wird Versionsverwaltung eingesetzt? Kläre, welche Software eingesetzt wird und welche Inhalte damit versioniert werden. In meinem Betrieb werden beispielsweise auch Dokumente im Fachbereich mit Subversion verwaltet. Git kommt unter anderem für Quellcode und Textdokumente zum Einsatz.

Wie richtest du deinen Arbeitsplatz ein? Frage dein:e Ausbilder:in oder eine:n Administrator:in,...

Einige grundsätzliche Fragen zur Versionsverwaltung mit Git sind der Inhalt der sechsundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Ich führe dich als IT-Azubi in die Grundlagen von Git ein, damit du Änderungen an deinem Quellcode nachvollziehen und gespeicherte Stände wiederherstellen kannst. Git hält die Projekthistorie lokal vor, wodurch du auch offline arbeiten und eigene Commits vor dem Teilen korrigieren kannst. Du erfährst, wie Repository und Arbeitskopie zusammenhängen, wie du mit git clone und git pull einsteigst und welche Informationen zu einem Commit gehören.

Kapitelmarken

[00:00:01] Einführung in Git

[00:00:33] Fragen zum Selbstlernen und Material zum Herunterladen

[00:01:57] Git in der Ausbildung und im Betrieb

[00:03:14] Tutorials und weiterführende Lernangebote

[00:04:58] Allgemeine Grundlagen und betriebliche Fragen

[00:06:14] Wozu Versionsverwaltung dient

[00:07:55] Gespeicherte Stände und Änderungen nachvollziehen

[00:11:09] Subversion als zentrale Versionsverwaltung

[00:12:01] Lokal und offline mit Git arbeiten

[00:14:10] Eigene Versionen korrigieren und lauffähige Stände teilen

[00:16:11] Repository und der Ordner .git

[00:19:44] Ein Repository mit git clone kopieren

[00:23:06] Die Arbeitskopie und ältere Stände auschecken

[00:25:42] Änderungen mit git pull holen

[00:27:49] Commits und ihre Kennung

[00:29:09] Hashes als Prüfsummen und Commit-IDs

[00:31:45] Angaben im Commit und Parent-Commits

[00:33:45] Weitere Fragen und Fortsetzung der Git-Einführung

[00:34:58] Podcast-Empfehlung Together We Make IT

[00:36:01] Git für eigene Projekte und Texte

Inhalt

Allgemeine Fragen

Wofür braucht man eine Versionsverwaltungssoftware?

Was sind die Vorteile einer Versionsverwaltungssoftware?

Was ist SVN?

Was ist Git?

Was sind die Vorteile von Git gegenüber SVN?

Was ist ein Repository?

Welche Befehle musst du ausführen, um dir ein Repository zu klonen?

Was ist eine Arbeitskopie?

Welche Befehle musst du ausführen, um deine Arbeitskopie aus einem entfernten Repository zu aktualisieren?

Was ist ein Commit?

Literaturempfehlungen

Git Tutorial – The Ultimate Guide (Julen Pardo)

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Git

Git Cheat Sheet

Zusammenfassung

Git in deiner IT-Ausbildung

Für meine IT-Azubis habe ich Fragen zusammengestellt, die du mithilfe eines Tutorials selbst bearbeitest und anschließend mit meinen Antworten abgleichst. Dabei geht es um die Grundlagen von Git sowie um Regeln, die du für die Arbeit in deinem Ausbildungsbetrieb kennen musst. Versionsverwaltung gehört zum Handwerkszeug als Fachinformatiker:in Anwendungsentwicklung und ist auch für die Prüfung relevant.

Ich arbeite bei neuen Projekten mit Git und verwalte damit auch eigene Texte. In meinem Betrieb kommt Git für die meisten Repositories zum Einsatz; einige ältere Projekte liegen noch in Subversion.

Dateien versionieren und Änderungen nachvollziehen

Wenn du an einem Programm weiterarbeitest, kannst du einzelne Stände in einer Versionsverwaltung speichern und später wiederherstellen. Die Historie zeigt dir, welche Person eine Datei zu welchem Zeitpunkt verändert hat. Eine aussagekräftige Commit-Nachricht hält außerdem fest, warum etwas geändert wurde.

Änderungen ansehen: Ein Diff zeigt die Unterschiede zwischen zwei Ständen. Bei Textdateien lassen sich hinzugefügte oder entfernte Zeilen gezielt erkennen, etwa wenn ich einen Text von dir korrigiere.

Zu einem gespeicherten Stand zurückkehren: Falls du beim Ausprobieren eine Datei löschst oder dein Programm beschädigst, kannst du einen früheren Stand wiederherstellen.

Fehler untersuchen: Über die Historie findest du heraus, wer eine betroffene Codezeile zuletzt bearbeitet hat und in welchem Zusammenhang das passiert ist.

Quellcode im Browser ansehen: Über eine passende Weboberfläche kannst du Dateien und ihre Änderungen durchgehen.

Textdateien eignen sich besonders gut zum Versionieren, weil sich ihre Unterschiede zeilenweise darstellen lassen. Auch Bilder und andere binäre Dateien können verwaltet werden, wobei neue Stände mehr Speicherplatz beanspruchen können.

Wie Subversion und Git arbeiten

Subversion

Bei Subversion, kurz SVN, liegt das Repository auf einem zentralen Server. Du bearbeitest deine Dateien lokal und überträgst einen fertigen Stand an diesen Server, der die neue Version mit den zugehörigen Angaben speichert. Für solche Schritte muss der Server erreichbar sein.

Die gespeicherten Versionen heißen Revisionen und erhalten fortlaufende Nummern.

Git

Mit Git liegt die gesamte Projekthistorie auf deiner Festplatte. Dadurch kannst du offline neue Versionen erzeugen und frühere Änderungen ansehen. Viele Arbeitsschritte laufen lokal und entsprechend schnell ab.

Solange du eigene Commits noch mit niemandem geteilt hast, kannst du sie korrigieren, beispielsweise wenn du eine Datei vergessen hast. Für die Zusammenarbeit lässt sich dein lokales Repository mit einem entfernten Remote-Repository abgleichen. Dort liegen deine Daten zusätzlich außerhalb deines Rechners.

Bevor du einen Stand mit Kolleg:innen teilst, sollte das Programm lauffähig und zumindest kompilierbar sein, damit sie damit weiterarbeiten können.

Repository und Arbeitskopie

Im Repository, häufig kurz Repo genannt, speichert Git die Versionen deines Projekts samt Historie. Du kannst es dir als Datenbank vorstellen. Lokal liegen diese Informationen im Ordner .git innerhalb deines Projektverzeichnisses. Wenn du diesen Ordner löschst oder seinen Inhalt von Hand veränderst, kannst du deine lokale Historie verlieren oder beschädigen. Lass Git diesen Ordner verwalten.

In der Arbeitskopie liegen die Dateien eines konkreten Stands, die du im Editor öffnest und bearbeitest. Nach dem Klonen stellt Git normalerweise den aktuellen Stand bereit. Du kannst auch eine ältere Version auschecken, etwa um dort einen Fehler zu untersuchen oder einen Patch einzuspielen.

Wenn du Dateien in deiner Arbeitskopie bearbeitest, musst du die Änderungen anschließend ausdrücklich als neue Version im Repository speichern.

Ein vorhandenes Projekt holen

Mit git clone kopierst du ein vorhandenes Repository auf deinen Rechner. Die Adresse kann beispielsweise auf einen lokalen Pfad oder auf ein Repository zeigen, das über HTTPS beziehungsweise SSH erreichbar ist. Welche Adresse und welchen Zugang du brauchst, klärst du in deinem Ausbildungsbetrieb.

Beim normalen Klonen erhältst du die vollständige Historie des entfernten Repositories und eine Arbeitskopie, in der du direkt weiterarbeiten kannst. Bei großen Projekten dauert das Herunterladen entsprechend länger.

Neue Änderungen holen

Wenn Kolleg:innen neue Stände im Remote-Repository bereitgestellt haben, holst du sie mit git pull. Im beschriebenen einfachen Fall, in dem du zwischenzeitlich selbst nichts geändert hast, gelangen die neuen Versionen in dein lokales Repository und deine Arbeitskopie wird aktualisiert.

Mit Push überträgst du eigene Versionen an ein Remote-Repository, um sie dort bereitzustellen.

Was zu einem Commit gehört

Eine gespeicherte Version heißt bei Git Commit. Zu ihr gehören:

der gespeicherte Stand der Dateien,

die Angaben zum/zur Autor:in und der Zeitpunkt,

die Commit-Nachricht,

der Bezug zum vorherigen Commit, dem Parent-Commit.

Ein Commit kann auch zwei Parent-Commits haben. Dieses Thema folgt später.

Git berechnet aus den zugehörigen Informationen einen Hash, der als Commit-ID dient. Eine Hashfunktion erzeugt aus Daten variabler Länge einen Wert fester Länge, der sich als Prüfsumme verwenden lässt. Schon kleine Änderungen an den Ausgangsdaten führen bei einem geeigneten Verfahren zu einem deutlich anderen Hash.

Die Commit-ID wird hexadezimal dargestellt. Um die zeitliche Reihenfolge der Commits nachzuvollziehen, brauchst du die Historie und die Beziehungen zu den Parent-Commits. Über die ID kannst du einen gespeicherten Commit gezielt aufrufen.

Material zum Selbstlernen

In meinen Shownotes zur Episode 76 findest du die Fragen und weiterführende Links. Über meinen Newsletter erhältst du die Fragen auch als Markdown-Datei zum Bearbeiten oder Ausdrucken.

Java Code Geeks: Das kostenlose Git-Tutorial umfasst ungefähr 40 Seiten und enthält Beispiele zum Mitmachen.

Pro Git von Scott Chacon: Das Buch ist als kostenloses E-Book und als gedruckte Ausgabe erhältlich.

Pluralsight: Ich verweise auf einen Einstiegskurs und erwähne einen weiteren Kurs zu den internen Abläufen von Git.

Die weiteren Fragen folgen in einer nächsten Episode. Dazu gehören auch betriebliche Konventionen und der Zugang zu den Repositories deines Ausbildungsbetriebs.

Für weitere IT-Grundlagen empfehle ich Together We Make IT. Dort werden unter anderem Firewall und Cloud Computing verständlich behandelt. Die Folgen dauern meist etwa 20 bis 30 Minuten und enthalten Begriffe, die dir auch bei der Abschlussprüfung begegnen.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:01] Herzlich Willkommen zum Anwendungsentwickler-Podcast, den Podcast rund um die Ausbildung zum Fachinformatiker für Anwendungsentwicklung.

[0:10] In dieser Episode gibt es eine Einführung in die Versionsverwaltungssoftware Git. Viel Spaß dabei!

[0:20] Hallo und herzlich Willkommen zur 76. Episode des Anwendungsentwickler-Podcasts.

[0:26] Mein Name ist Stefan Macke und heute mache ich mal was Neues, was ich bislang noch nicht gemacht habe hier im Podcast.

[0:33] Ich habe nämlich mal mir ein fachliches Thema vorgenommen und zwar Git, die Versionsverwaltungssoftware Git, die du vielleicht sogar schon kennst oder ich hoffe es mal, ist ja sehr verbreitet heutzutage.

[0:41] Und ich habe mir mal so ein paar Fragen dazu aufgeschrieben, die ich vor ein, zwei Wochen meinem aktuellen Azubi mitgegeben habe,

[0:48] damit er sich mal mit einem Tutorial, was ich ihm gleich mitgeschickt habe, so ein bisschen darauf vorbereitet, quasi selbst so ein bisschen recherchiert, ausprobiert, das Ding abarbeitet und dann mir die Fragen beantwortet.

...

Die beiden kurzen Kapitel 17 (Weitere Datei- und Datenformate) und 21 (Computer- und Netzwerksicherheit) sind Inhalt der fünfundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Ich gehe mit dir die Kapitel 17 und 21 des Handbuchs für Fachinformatiker:innen durch, die Datei- und Datenformate sowie Computer- und Netzwerksicherheit behandeln. Für deine Prüfung brauchst du Kenntnisse über Zeichencodierungen und Dateiformate sowie klare Definitionen der Sicherheitsbegriffe. Praxisbeispiele zeigen dir, wie du Dateien mit einem Hexeditor untersuchst oder Linux-Server absicherst. Bei Audio- und Videoformaten sowie Kryptografie empfehle ich dir ergänzende Quellen, damit du die Themen ausreichend für die Prüfung verstehst.

Kapitelmarken

[00:00:20] Episode 75 und die Kapitel im Buchclub

[00:01:57] Textdateien und Zeichensätze

[00:02:26] Encoding-Probleme mit PowerShell und Git

[00:04:33] Zeichensätze für die Prüfung

[00:05:09] LaTeX und Projektdokumentation

[00:06:04] Binäre Dateiformate

[00:06:55] Dateien mit einem Hexeditor untersuchen

[00:07:45] Bildformate und Kompression

[00:10:10] Audio- und Videoformate

[00:11:42] TAR-Archive unter Linux

[00:12:48] Computer- und Netzwerksicherheit

[00:13:08] Viren, Würmer und Schutzmaßnahmen

[00:14:30] Trojaner, Backdoors, Spyware und Adware

[00:14:59] Phishing und Spam in der Prüfung

[00:16:10] Gefahren für Netzwerke und Server

[00:16:48] SQL-Injection und OWASP Top 10

[00:19:28] Firewalls und Intrusion Detection Systems

[00:20:10] Linux-Firewalls mit iptables konfigurieren

[00:21:07] Kryptografie und hybride Verschlüsselung mit HTTPS

[00:22:59] Digitale Signaturen, Hashverfahren und ergänzende Literatur

[00:23:43] Die Kapitel im ersten Ausbildungsjahr lernen

[00:24:42] Weitere Themen im Buchclub

[00:25:34] Newsletter und Links der Woche

Inhalt

Kapitel 17 (Weitere Datei- und Datenformate)

Textdateien und Zeichensätze

Ein absolut praxisrelevantes Thema! Muss mein aktueller Azubi gerade lernen. :-) Auch die Zeilenumbrüche nicht vergessen!

Ein paar ASCII-Zeichen darf man als Programmierer auch kennen! Und wie heißt der Standard-Zeichensatz in Deutschland?

Das kurze Kapitel zu LaTeX ist natürlich auch sehr wichtig! ;-)

Binäre Dateiformate

Schöne Erklärung für die Praxis (mit Hex-Editor).

Verlustbehaftete und verlustfreie Komprimierung sollte jeder Prüfling erklären können.

Die Unterschiede verbreiteter Bildformate sind sowohl praxis-, als auch prüfungsrelevant.

Das Gleiche gilt für Audio- und Videoformate.

Kapitel 21 (Computer- und Netzwerksicherheit)

PC-Gefahren

Wichtige Begriffsdefinitionen für die Prüfung (z.B. Viren, Würmer, Trojaner). Phishing und Spam waren gerade in der letzten Sommerprüfung Thema.

Netzwerk- und Serversicherheit

Es geht weiter mit ebenso wichtigen Begriffen: Exploits, DoS, Rootkits, SQL-Injection, Firewalls, IDS.

Praxisbeispiel iptables ist interessant für den eigenen Server.

Die Einführung in die Kryptographie ist auch sehr praxis- und prüfungsrelevant. Gerade symmetrische und asymmetrische Verschlüsselung sollte jeder ITler kennen.

Literaturempfehlungen

*(direkt beim Rheinwerk-Verlag bestellen*)

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Zeichensätze und -kodierung - Anwendungsentwickler-Podcast #32

Pflichtlektüre rund um Zeichensätze und Encodings

Einführung in LaTeX: 00. Einleitung

Category:OWASP Top Ten Project - OWASP

Zusammenfassung

Die Kapitel im Buchclub

In der zehnten Folge meines Buchclubs behandle ich Kapitel 17 zu weiteren Datei- und Datenformaten sowie Kapitel 21 zur Computer- und Netzwerksicherheit. Beide enthalten Grundlagen, die du als IT-Azubi bereits im ersten Ausbildungsjahr lernen kannst. Viele Begriffe werden in der schriftlichen Prüfung abgefragt; SQL-Injection spreche ich auch im mündlichen Fachgespräch an, wenn entsprechende Schwachstellen im gezeigten Code auftauchen.

Textdateien und Zeichencodierungen

Wenn du Dateien schreibst oder einliest, musst du die passende Zeichencodierung berücksichtigen. Andernfalls erscheinen Zeichen falsch oder ein Werkzeug interpretiert die Datei unerwartet.

Bei meinem neuen Azubi trat das während der Arbeit mit Git und PowerShell auf: Die damals verwendete PowerShell schrieb per Ausgabeumleitung Textdateien in UTF-16. Git erwartete UTF-8 und behandelte die erzeugten Dateien als Binärdateien. Im Editor ließ sich der Inhalt lesen, während Git ihn anders interpretierte.

Für deine Ausbildung solltest du folgende Begriffe kennen:

ASCII

Unicode und die dazugehörige UTF-8-Codierung

UTF-16

ANSI

ISO-8859-1 als westeuropäischen Zeichensatz

Zu Encoding habe ich bereits eine eigene Podcastfolge veröffentlicht. In meinen Shownotes findest du außerdem weitere Links zum Thema.

LaTeX für deine Projektdokumentation

Das Buch enthält einen kurzen Abschnitt zu LaTeX, mit dem ich längere Dokumente schreibe. Für deinen Einstieg stehen meine kostenlose, zehnteilige Videoreihe und eine Vorlage für die Projektdokumentation bereit. Die Links findest du ebenfalls in den Shownotes.

Binäre Dateiformate und Hexeditoren

Mit einem Hexeditor kannst du die gespeicherten Bytes einer Datei ansehen. Das hilft dir auch dabei, nachzuvollziehen, wie verschiedene Zeichencodierungen einen Text auf der Festplatte ablegen. Das Buch führt mit einem Praxisbeispiel in dieses Werkzeug ein.

Bildformate und komprimierte Dateien

Bei verlustfreier Kompression bleiben die Informationen erhalten, während die Datei kleiner wird. Verlustbehaftete Kompression, etwa bei JPEG, verringert die Dateigröße und lässt Bildqualität verloren gehen.

Für die Prüfung solltest du GIF, PNG, BMP, TIFF und JPEG mit ihren Eigenschaften kennen. Dazu gehören die Farbtiefe und das jeweilige Verfahren zum Komprimieren. Eine Aufgabe kann verlangen, dass du ein Format für Bilder auf einer Website auswählst und deine Wahl begründest. Auch das Berechnen von Datenmengen gehört zu den angesprochenen Aufgaben.

Einige Eigenschaften werden konkret genannt:

GIF arbeitet mit 8 Bit Farbtiefe und kann animierte Bilder speichern.

JPEG wird häufig für Fotos verwendet; im besprochenen Beispiel beträgt die Farbtiefe 24 Bit.

PNG kann einen Alphakanal mit 8 Bit für Transparenz enthalten.

Audio- und Videoformate

Für die Prüfung brauchst du Kenntnisse über WAV und MP3 sowie über die üblichen Abtastraten und Sampletiefen. Als Bezugspunkt dient CD-Qualität mit 44,1 kHz Abtastrate und 16 Bit Sampletiefe. Solche Angaben helfen dir, Datenmengen zu berechnen und Eigenschaften von Formaten zu beurteilen.

Die ungefähr zwei Seiten im Buch behandeln diese Themen knapp. Für deine Prüfung empfehle ich dir, sie weiter zu vertiefen. Bei JPEG und MPEG solltest du die ausgeschriebenen Namen kennen und das Verfahren grob beschreiben können. Der erwartete Umfang bleibt bei den Grundlagen; wissenschaftliche Details wie eine Fourier-Transformation gehen darüber hinaus.

Archive unter Linux

Ein Praxisbeispiel zeigt, wie du mit dem Kommandozeilenwerkzeug tar Dateien packst und entpackst. Das brauchst du beispielsweise, wenn du heruntergeladene Quelltexte aus einem TAR-Archiv holen möchtest, bevor du sie selbst kompilierst.

Gefahren für deinen PC

Zu Viren und Würmern solltest du erklären können, wie sie sich verbreiten und welche Merkmale sie haben. Auch Polymorphie bei Viren gehört zu den angesprochenen Fachbegriffen.

Weitere Begriffe aus dem Kapitel sind:

Trojaner

Backdoors

Spyware und Adware

Phishing

Spam

Lege dir zu jedem Begriff eine kurze, eindeutige Definition zurecht, die du in der Prüfung aufschreiben kannst. Bei Fragen zum Schutz eines PCs kommen beispielsweise eine Firewall und ein Virenscanner infrage.

Spam und Phishing

In der Sommerprüfung 2016 wurden beide Begriffe abgefragt. Beim Korrigieren habe ich erlebt, dass viele Prüflinge die Definitionen durcheinanderbrachten.

Spam umfasst unerwünschte Nachrichten, beispielsweise mit Werbung.

Phishing zielt darauf ab, vertrauliche Daten wie Passwörter abzugreifen.

Netzwerk- und Serversicherheit

Wenn du einen Server betreibst oder Anwendungen entwickelst, brauchst du Kenntnisse über die Angriffe, denen diese ausgesetzt sein können. Im Kapitel werden unter anderem folgende Begriffe behandelt:

Exploits

DoS- und DDoS-Attacken

Rootkits

SQL-Injection

Session-Hijacking

SQL-Injection und OWASP Top 10

SQL-Injection kann entstehen, wenn eine Anwendung Eingaben von Benutzer:innen ungeprüft in SQL-Zeichenketten einbaut und diese an die Datenbank sendet. Das Buch macht den Angriff anhand eines kurzen Praxisbeispiels nachvollziehbar.

Für den Umgang mit Parametern stehen Funktionen der jeweiligen Datenbank-Frameworks bereit. Darüber kannst du Parameter verarbeiten und escapen lassen, ohne SQL-Zeichenketten selbst aus den Eingaben zusammenzusetzen.

Die OWASP Top 10 geben einen Überblick über verbreitete Sicherheitslücken. Injections standen zum Zeitpunkt der Aufnahme seit Jahren weit oben auf dieser Liste. Du solltest die dort beschriebenen Risiken erklären können und beim Entwickeln berücksichtigen. In meinen Shownotes verlinke ich die Liste; außerdem erwähne ich einen Pluralsight-Kurs von Troy Hunt, der Gegenmaßnahmen anhand von Beispielen zeigt.

Firewalls und Intrusion Detection Systems

Zu den prüfungsrelevanten Grundlagen gehören auch die Begriffe Firewall und Intrusion Detection System. Das Buch zeigt anschließend über mehrere Seiten, wie du mit iptables eine Firewall auf einem Linux-Server konfigurierst.

Meine Azubis sichern ihre Server damit ab. Die beschriebenen Parameter und Beispiele helfen beim praktischen Einstieg. Für die Prüfung stehen die allgemeinen Grundlagen im Vordergrund, da die konkrete iptables-Konfiguration produktspezifisch ist.

Kryptografie

Bei symmetrischen und asymmetrischen Verfahren solltest du verstehen, wie sie arbeiten und welche Eigenschaften sie haben. Zur asymmetrischen Verschlüsselung gehören außerdem die Rollen von Public Key und Private Key sowie die Frage, wer welchen Schlüssel haben darf.

An HTTPS lässt sich das Zusammenspiel als hybrides Verfahren erläutern: Ei

18 hilfreiche Firefox-Plugins nicht nur für Webentwickler stelle ich in der vierundsiebzigsten Episode des Anwendungsentwickler-Podcasts vor.

TL;DR

Für meinen Arbeitsalltag habe ich Firefox mit 18 Erweiterungen angepasst, die dir auch als IT-Azubi helfen können. Neun davon erleichtern den Umgang mit dem Browser, etwa beim Anmelden, beim Schreiben in Formularen oder beim Lesen und Anschauen gespeicherter Inhalte. Weitere neun helfen dir bei der Webentwicklung, wenn du HTML prüfst, JavaScript debuggst oder Layouts und HTTP-Daten untersuchst. Beim ergänzenden Thema Tabs und Spaces kommt es darauf an, dass dein Team einheitlich arbeitet.

Kapitelmarken

[00:00:01] Einführung: 18 Firefox-Erweiterungen

[00:00:59] Firefox im Arbeitsalltag und eigener Sync-Server

[00:02:27] Allgemeine Plugins und Werkzeuge für die Webentwicklung

[00:04:05] Vimperator: Firefox mit Vim-Tastenkürzeln steuern

[00:05:47] FireGestures: Browserbefehle über Mausgesten

[00:07:33] KeeFox: Zugangsdaten aus KeePass eintragen

[00:09:01] It's All Text: Formulartexte im Texteditor bearbeiten

[00:11:04] Lazarus: Formulareingaben wiederherstellen

[00:12:21] Make Link: Formatierte Links kopieren

[00:13:51] Send to Kindle: Lange Artikel später lesen

[00:14:51] Video DownloadHelper: Videos offline anschauen

[00:16:20] Zotero: Literatur und PDFs verwalten

[00:18:23] Web Developer Toolbar: Webseiten untersuchen und verändern

[00:19:23] HTML Validator: Gültiges HTML prüfen

[00:20:20] Firebug: JavaScript debuggen und Webseiten untersuchen

[00:21:12] ColorZilla: Farbcodes auslesen

[00:22:16] MeasureIt: Abstände und Maße in Pixeln prüfen

[00:23:03] FireShot: Komplette Webseiten als Screenshot speichern

[00:24:22] Linkification: Textadressen anklickbar machen

[00:25:32] Live HTTP Headers: Requests und Responses untersuchen

[00:26:20] Advanced Cookie Manager: Cookies prüfen und verändern

[00:26:52] Überblick über die 18 Plugins und Shownotes

[00:27:40] Tabs und Spaces: Konventionen und einheitlicher Code im Team

Inhalt

Allgemein

Vimperator: Ohne Vim-Steuerung ist der Firefox nicht zu gebrauchen ;-)

FireGestures: Aber auch die Maussteuerung kann deutlich optimiert werden.

KeeFox: Nie wieder Passwörter eintippen!

It's All Text!: Formulare im Lieblingseditor ausfüllen.

Lazarus: Form Recovery: Lazarus hat mich schon mehrfach vor dem erneuten Eintippen riesiger Formulare bewahrt.

Make Link: Unerlässlich, wenn man Texte (wie diesen) mit Markdown schreibt.

Send to Kindle for Mozilla Firefox: Für lange Artikel eine einfache Lösung, sie offline zu lesen.

*

Video DownloadHelper: Wenn einem die doppelte Geschwindigkeit von YouTube nicht reicht ;-)

Zotero: Die Literaturverwaltung meiner Wahl.

Webentwicklung

Web Developer: Das schweizer Taschenmesser für jeden Webentwickler.

Html Validator: Sauberes Markup sollte für jeden Entwickler Pflicht sein.

Firebug: Was kann dieses Tool nicht?

ColorZilla: Sehr hilfreich bei der Überprüfung von Farbvorgaben.

MeasureIt: Für pixelgenaue Layouts unerlässlich.

Fireshot: Sehr hilfreich bei der Abstimmung von Entwürfen mit dem Kunden.

Linkification: Ein nettes Helferlein.

Live HTTP Headers: Gerade in Zeiten von REST sehr hilfreich.

Advanced Cookie Manager: Na, wer spioniert mich da aus?

Literaturempfehlungen

Falls du den Vim noch nicht "beherrschst", wird es Zeit! ;-)

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Zusammenfassung

Firefox in meinem Arbeitsalltag

Ich arbeite seit Jahren mit Firefox und habe den Browser durch Erweiterungen an meine Aufgaben angepasst. Für meine Lesezeichen betreibe ich einen eigenen Sync-Server, damit die Daten auf meinem Server liegen. Die hier vorgestellten 18 Plugins verteilen sich auf neun allgemeine Erweiterungen und neun für Webentwickler:innen.

Über F12 erreichst du bereits die eingebauten Entwicklerwerkzeuge von Firefox. Dort kannst du JavaScript untersuchen und HTML sowie CSS verändern. Die zusätzlichen Plugins erweitern diese Möglichkeiten.

Neun Erweiterungen für den Alltag

Vimperator: Damit steuere ich Firefox über die Tastenkürzel aus Vim. Mit D lässt sich ein Tab schließen, während T einen neuen öffnet. Wenn du F drückst, erscheinen Zahlen an Links und anklickbaren Formularelementen. Über diese Zahlen kannst du direkt mit der Tastatur navigieren. Auch beim Scrollen stehen dir die gewohnten Vim-Befehle zur Verfügung.

FireGestures: Mit gedrückter rechter Maustaste zeichnest du Gesten, die Browserbefehle ausführen. So kannst du etwa einen Tab schließen oder zum Seitenende springen. Eigene Gesten lassen sich zusätzlich festlegen.

KeeFox: Das Plugin verbindet Firefox mit KeePass, wo ich meine Passwörter verschlüsselt speichere. Anhand hinterlegter URLs erkennt es passende Zugangsdaten. Mit Strg + Umschalt + 2 werden die Felder ausgefüllt und das Formular abgeschickt.

It's All Text: Über einen kleinen Button an einem Textfeld öffnest du dessen Inhalt in einem frei wählbaren Texteditor. Dort stehen dir beispielsweise die vertrauten Tastenkürzel und Syntax-Highlighting für Markdown zur Verfügung. Sobald du die Datei speicherst, erscheint der geänderte Text im Browser. Die Datei bleibt im temporären Verzeichnis auf der Festplatte erhalten, sodass du nach einem Browserabsturz darauf zugreifen kannst. Beim erneuten Öffnen der Seite kann das Plugin den Text wieder dem Formular zuordnen.

Lazarus: Wenn du direkt in Formularfelder schreibst, merkt sich die Erweiterung deine Eingaben. Nach einem Absturz kannst du sie über das Kontextmenü wiederherstellen. Ich verwende das auch für Formulare mit vielen einzelnen Feldern.

Make Link: Über das Kontextmenü kopierst du die aktuelle Seite als formatierten Link in die Zwischenablage. Das Format lässt sich frei festlegen. Für meine mit Markdown geschriebenen Artikel habe ich eine passende Vorlage eingerichtet; auch HTML und BBCode sind möglich.

Send to Kindle: Längere Artikel schicke ich auf meinen Kindle, um sie später dort zu lesen. Die Erweiterung bereitet den Inhalt auf und entfernt Werbung, während die zum Text gehörenden Bilder erhalten bleiben.

Video DownloadHelper: Damit lade ich Videos herunter, etwa von YouTube oder Vimeo, und schaue sie später offline. Das hilft mir bei schlechtem WLAN und auf Zugfahrten. Die gespeicherten Dateien lassen sich in einem Media Player abspielen, in dem ich auch die Geschwindigkeit einstellen kann.

Zotero: In dieser Literaturverwaltung sammle ich Quellen mit ihren bibliografischen Angaben und PDF-Anhängen. Bei einem geöffneten Buch auf Amazon übernimmt das Plugin beispielsweise die Metadaten. Auch Inhalte einer Website lassen sich als Screenshot oder PDF anhängen. Meine Daten und Anhänge liegen auf meinem eigenen Server und werden zwischen meinen Rechnern synchronisiert. Für Literaturempfehlungen an IT-Azubis ergänze ich eigene Notizen, damit ich Quellen später wiederfinde.

Mit vielen installierten Plugins kann Firefox langsamer werden. Für bereits eingegebene Texte bieten It's All Text und Lazarus Wege, sie nach einem Absturz wiederzubekommen.

Neun Erweiterungen für Webentwickler:innen

Web Developer Toolbar: Die Werkzeugleiste bietet viele Funktionen, um Webseiten zu untersuchen. Du kannst Cookies bearbeiten oder CSS-Stile verändern und abschalten. Ebenso lassen sich Formulare deaktivieren sowie Bilder ein- und ausblenden.

HTML Validator: Ein Symbol zeigt dir, ob das HTML der aktuellen Seite gültig ist. Bei Fehlern bekommst du Hinweise auf die betroffene Stelle und darauf, wie du sie behebst, etwa bei einem fehlenden schließenden Tag. In meiner Ausbildung achte ich auf valides HTML; dabei spielt auch Barrierefreiheit eine Rolle.

Firebug: Das umfangreiche Werkzeug hilft unter anderem beim Debuggen von JavaScript. Für Firebug gibt es eigene Erweiterungen. Ein genanntes Beispiel von Yahoo untersucht, wie lange einzelne Bestandteile einer Webseite zum Laden brauchen.

ColorZilla: Mit der Farbpipette liest du Farbcodes direkt im Browser ab und kopierst sie in die Zwischenablage. So kannst du kontrollieren, ob die Farben einer Website den Vorgaben entsprechen.

MeasureIt: Du ziehst ein Rechteck auf und bekommst dessen Breite und Höhe in Pixeln angezeigt. Damit lassen sich Abstände im Layout prüfen, auch wenn der betreffende Bereich aus mehreren Seitenelementen besteht.

FireShot: Die Erweiterung erstellt Screenshots kompletter Webseiten einschließlich der Bereiche außerhalb des sichtbaren Fensters. Das Ergebnis kannst du beispielsweise als JPEG oder PDF speichern und per E-Mail verschicken. Ich verwende solche Bilder, um mit dem Fachbereich Änderungen an einer Seite zu besprechen.

Linkification: Als Text eingetragene URLs werden automatisch anklickbar. Die Erweiterung erkennt neben HTTP-Adressen auch FTP- und Mailto-Verweise, sodass du sie direkt öffnen kannst.

Live HTTP Headers: Damit schaust du dir die HTTP-Header von Request und Response an. Bei REST-Diensten kannst du beispielsweise prüfen, welcher Accept-Header gesetzt wurde und welches Datenformat zurückkommt. Auch Angaben zu gzip, Content-Length und Statuscodes lassen sich untersuchen.

Advanced Cookie Manager: Das Plugin zeigt die Cookies im Browser an und erlaubt dir, Werte zu ändern oder herauszukopieren. Ich verwende es unter anderem, um Session Hijacking zu demonstrieren. Durch gezielt veränderte Cookie-Werte lässt sich außerdem prüfen, wie eine Website auf fehlerhafte Daten reagiert.

Die Links zu den Erweiterungen stehen in meinen Shownotes zur Episode 74 auf anwendungsentwicklerpodcast.de.

Tabs und Spaces im Quellcode

Als ergänzenden Artikel habe ich eine Untersuchung verlinkt, die sich mit Tabs und Spaces in vielen Open-Source-Projekten beschäftigt. Bisher habe ich Tabs bevorzugt, weil sich ihre angezeigte Breite im Editor individuell einstellen lässt. Durch den Artikel denke ich darüber nach, künftig häufiger mit Spaces zu arbeiten.

Welche Variante du verwendest, hängt auch vom Projekt und den Konventionen der jeweiligen Sprache oder Plattform ab. In Java-Projekten sind Spaces häufig verbreitet....

Das Kapitel 16 (XML) des IT-Handbuchs für Fachinformatiker* ist das Thema der dreiundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

XML steht für Extensible Markup Language und erlaubt dir, eigene Auszeichnungssprachen für strukturierte Daten festzulegen. Für deine Prüfung als Fachinformatiker:in Anwendungsentwicklung solltest du die Regeln für wohlgeformte Dokumente kennen und verstehen, wie du XML gegen ein Schema prüfst. Aus meiner Praxis gehören XML-Schema und XPath zum Handwerkszeug; beim Verarbeiten von Dateien hängt die Wahl zwischen DOM und SAX unter anderem von der Dateigröße ab.

Kapitelmarken

[00:00:20] Buchclub: XML im Handbuch für Fachinformatiker

[00:00:52] XML beim Datenaustausch zwischen Unternehmen

[00:03:38] Extensible Markup Language: Bedeutung und Grundidee

[00:05:29] XML für Menschen und Maschinen lesbar machen

[00:07:53] Tags, Elemente und Attribute

[00:09:41] Regeln für wohlgeformte XML-Dokumente

[00:12:21] Sonderzeichen und Entitätsreferenzen

[00:13:52] Gültige Inhalte mit DTD und XML-Schema beschreiben

[00:16:23] XML-Schema vertiefen und Literatur auswählen

[00:17:50] XML-Schema und gültige Dokumente

[00:19:15] Prüfungsfragen zu Wohlgeformtheit und Validität

[00:21:04] Namensräume und Präfixe

[00:23:05] Weltweit eindeutige Kennungen für Namensräume

[00:24:49] XML-Dokumente mit XSLT umwandeln

[00:26:57] Mit XPath auf Elemente und Attribute zugreifen

[00:28:51] Grundlagen der XML-Programmierung

[00:29:42] XML-Dateien mit DOM und SAX verarbeiten

[00:31:31] Quelltextbeispiele und sprachübergreifende APIs

[00:32:51] Das XML-Kapitel und ergänzende Literatur

[00:34:13] Shownotes und Newsletter

[00:35:15] Konferenz zur Softwareentwicklung im Mittelstand

Inhalt

XML ist - trotz der wachsenden Beliebtheit von JSON - immer noch eines der wichtigsten Austauschformate in der IT. Das entsprechende Kapitel des IT-Handbuchs für Fachinformatiker* enthält viele prüfungs- und praxisrelevante Inhalte.

XML

Der Aufbau von XML-Dokumenten

Extensible nicht extended!

Vorteile: Menschen- und maschinenlesbar

Element vs. Tag

Wohlgeformtheit: nur ein Wurzelelement, korrekte Schachtelung der Elemente, alle Elemente müssen geschlossen werden, nur erlaubte Elementnamen, Attributwerte immer in Anführungszeichen, Sonderzeichen durch Entitätsreferenzen ersetzen

DTDs und XML Schema

DTDs benutzt kein Mensch mehr (hoffentlich). Schemas sind der Standard.

Kapitel zu DTD ist recht lang, Schema kommt zu kurz.

Namensräume sind sehr wichtig in der Praxis.

XSLT

Gut zu wissen, in der Praxis und der Prüfung wahrscheinlich nicht allzu wichtig.

XPath hingegen ist wichtig für die Praxis.

Grundlagen der XML-Programmierung

SAX vs. DOM ist absolut praxisrelevant.

Literaturempfehlungen

*(direkt beim Rheinwerk-Verlag bestellen*)

Ich selbst habe vor mehreren Jahren mit einer älteren Auflage von Einstieg in XML* von Helmut Vonhoegen XML gelernt und es hat mir sehr gut gefallen. Das Buch ist umfangreich und gut verständlich geschrieben.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Zusammenfassung

XML beim Datenaustausch

In meinem Arbeitsumfeld verlangen viele Unternehmen XML als Austauschformat. Mit einem Schema lassen sich Schnittstellen verbindlich beschreiben, sodass beide Seiten ihre Dokumente prüfen können, bevor sie die Daten weiterverarbeiten. Als IT-Azubi begegnet dir XML deshalb in der Praxis und in Prüfungen.

Bei Schnittstellen, über die Daten ohne vorgegebenes Schema ausgetauscht werden, können Änderungen an der Struktur schwer nachzuvollziehen sein. Für den Austausch zwischen Unternehmen lege ich Wert auf festgelegte Datentypen und darauf, Dokumente automatisch prüfen zu können.

Was XML bedeutet

XML heißt Extensible Markup Language, übersetzt etwa "erweiterbare Auszeichnungssprache". Als Entwickler:in kannst du damit eine eigene Sprache festlegen. XML gibt die Syntax vor, während du bestimmst, welche Elemente deine Dokumente enthalten und wie sie ineinander geschachtelt werden dürfen. Auch Attribute und erlaubte Werte kannst du vorgeben.

Durch sprechende Namen wie Adresse oder Straße werden die Inhalte für Menschen verständlich. Ein Parser kann die festgelegte Syntax auswerten und die einzelnen Bestandteile erkennen. XML beschreibt dabei die Struktur und Bedeutung von Daten.

Elemente und Attribute

Ein Tag enthält einen Namen in spitzen Klammern, etwa . Zum vollständigen Element gehören das öffnende Tag, sein Inhalt sowie das schließende Tag: Moorweg.

Attribute stehen als Schlüssel-Wert-Paare im öffnenden Tag. Im Beispiel Moorweg heißt das Attribut Typ und trägt den Wert Privatanschrift. Die Anführungszeichen gehören zur XML-Syntax.

Wann ein Dokument wohlgeformt ist

Für ein wohlgeformtes XML-Dokument hältst du die Syntaxregeln ein:

Das Dokument enthält genau ein Wurzelelement.

Alle Elemente sind korrekt geschachtelt. Bei schließt du zuerst B und anschließend A.

Jedes Element wird geschlossen. Für leere Elemente gibt es die Kurzschreibweise .

Die Elementnamen entsprechen den erlaubten Regeln.

Sämtliche Attributwerte stehen in Anführungszeichen.

Zeichen, die für die XML-Syntax eine besondere Bedeutung haben, werden im entsprechenden Kontext durch Entitätsreferenzen dargestellt.

Eine Entitätsreferenz beginnt mit &, gefolgt vom Namen der Entität und einem Semikolon. Das im Podcast genannte Beispiel > steht für >. Besonders bei mathematischen Ausdrücken musst du darauf achten, dass der Parser ein Zeichen wie < korrekt als Inhalt erkennt.

Auch wenn HTML5 Attributwerte ohne Anführungszeichen erlaubt, schreibe ich sie dort ebenfalls in Anführungszeichen.

Wie du gültige Inhalte festlegst

Mit einer DTD, einer Document Type Definition, oder einem XML-Schema beschreibst du, welche Inhalte ein Dokument enthalten darf. Gegen diese Vorgaben kannst du das Dokument prüfen. Ein syntaktisch korrektes Dokument mit Angaben zu einem Auto würde beispielsweise die Vorgaben einer Buchbestellung verfehlen.

DTDs haben eine eigene Syntax. In meiner Praxis habe ich sie seit Jahren nicht mehr eingesetzt, weshalb ich dir empfehle, dich mit XML-Schema zu beschäftigen. Ein XML-Schema ist selbst ein XML-Dokument und bietet mehr Möglichkeiten, Vorgaben zu beschreiben.

Ein valides Dokument ist immer wohlgeformt und erfüllt zusätzlich die Anforderungen der zugehörigen DTD oder des Schemas. Für die mündliche Prüfung frage ich solche Zusammenhänge ab:

Ein Dokument kann wohlgeformt und valide sein, wenn es die XML-Syntax und die vorgegebenen Inhalte erfüllt.

Ein wohlgeformtes Dokument kann die Schema-Vorgaben verletzen, etwa wenn ein Element Text enthält, obwohl eine ganze Zahl erwartet wird.

Bei fehlerhafter XML-Syntax scheitert bereits das Parsen. Damit fehlt auch die Voraussetzung für ein valides Dokument.

Beim Schreiben und Einlesen können beide Seiten ihre Dokumente gegen dasselbe Schema prüfen. Viele Frameworks stellen dafür Funktionen bereit.

Namensräume

Über Namensräume lassen sich gleichnamige Elemente verschiedenen fachlichen Bereichen zuordnen. Ein Element Name kann beispielsweise zu einem Buch oder zu einer Person gehören.

Ein Präfix vor dem Elementnamen macht diese Zuordnung sichtbar: Bei abc:Straße verweist abc auf den zugehörigen Namensraum. Im Dokument wird festgelegt, welcher Namensraum zu diesem Präfix gehört.

Die Kennung eines Namensraums sieht häufig wie eine URL aus. Sie dient als weltweit eindeutiger Name, wobei unter dieser Adresse keine erreichbare Webseite liegen muss. Eine eigene Domain hilft dabei, eindeutige Kennungen zu vergeben. Das Prinzip ähnelt Packages in Java beziehungsweise Namespaces in .NET. Für XML-Schema brauchst du dieses Verständnis ebenfalls.

XSLT und XPath

XSLT steht für Extensible Stylesheet Language Transformations. Die Sprache ist selbst in XML geschrieben und ermöglicht es, XML-Dokumente umzuwandeln, etwa in ein anderes XML-Format oder in eine CSV-Datei. Auch HTML kann daraus entstehen.

Mit Schleifen und Fallunterscheidungen ist XSLT eine vollständige, Turing-vollständige Programmiersprache. Wegen der ausführlichen XML-Syntax empfehle ich sie für allgemeines Programmieren wenig. Fragen zu XSLT erwarte ich in der Prüfung kaum.

Über XPath greifst du auf Elemente und Attribute im XML-Baum zu. Pfade bilden die Baumstruktur mit Schrägstrichen ab; @ kennzeichnet den Zugriff auf ein Attribut. XPath begegnet dir beim Arbeiten mit XSLT und beim Verarbeiten von XML in anderen Programmiersprachen. Für die Praxis empfehle ich dir, die Syntax kennenzulernen. In der Prüfung halte ich Fragen dazu für wenig wahrscheinlich.

XML mit DOM und SAX verarbeiten

DOM: Document Object Model

DOM lädt das gesamte Dokument in den Speicher und bildet es als Baum ab. Du kannst anschließend auf beliebige Elemente zugreifen und dich frei durch die Struktur bewegen. Für kleine XML-Dateien arbeite ich damit. Der Speicherbedarf hängt vom vollständigen Dokument ab.

SAX: Simple API for XML

SAX liest das Dokument fortlaufend von Anfang bis Ende und verarbeitet es über Callback-Methoden. Dadurch bleibt der Speicherbedarf gering. Der Zugriff folgt der Leserichtung; für bereits gelesene Inhalte gibt es keinen freien Rücksprung.

Bei großen Dateien setze ich SAX ein. In meinem Versicherungsumfeld werden beispielsweise XML-Dateien mit Hunderttausenden Datensätzen ausgetauscht. Solche Dateien können mehrere Gigabyte groß sein.

Als Anwendungsentwickler:in solltest du erklären können, welcher Ansatz zu deinem konkreten Fall passt. Diesen Unterschied habe ich bereits in mündlichen Prüfungen abgefragt. Die grundlegende Arbeitsweise bleibt über Programmiersprachen hinweg ähnlich, auch wenn du die konkrete API und Syntax nachschlagen musst.

Das Handbuch und weiterführende Literatur

Im Handbuch für Fachinformatiker von Sascha Kersten werden die Themen verständlich eingeführt. Meine IT-Azubis konnten die Beispiele nachvollziehen, darunter auch jemand, der XML gerade erst kennenlernte....

Die konkreten Punkte auf meinen Evaluierungsbögen für Auszubildende und Ausbilder sind das Thema der zweiundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Mit meinen Bewertungsbögen bekommst du als IT-Azubi regelmäßig Feedback dazu, wie du arbeitest und dich fachlich entwickelst. Du schätzt dich selbst ein und besprichst mit mir die einzelnen Punkte, damit du deinen Lernstand besser einordnen kannst. Außerdem bewertest du, wie ich dich betreue und wie du deine Ausbildung erlebst. Dafür führe ich wöchentlich halbstündige Einzelgespräche und alle sechs Monate ein längeres Gespräch anhand der Bögen.

Kapitelmarken

[00:00:20] Einstieg in die Bewertungsbögen

[00:00:47] Umgang mit Menschen und Feedback

[00:01:39] Aufgaben sorgfältig erledigen und Termine einhalten

[00:03:27] Eigeninitiative und selbstständiges Arbeiten

[00:05:18] Abläufe kritisch hinterfragen und automatisieren

[00:06:38] Zuverlässigkeit und unangenehme Aufgaben

[00:07:44] Aus eigenem Interesse dazulernen

[00:09:19] Zusammenhänge erkennen und Neues verstehen

[00:10:44] Kreativität und Probleme lösen

[00:12:30] Lernstand in Schule und Betrieb bewerten

[00:13:26] Systematisch vorgehen und Aufgaben planen

[00:14:25] Eigene Ideen in den Betrieb einbringen

[00:16:01] Selbst- und Fremdeinschätzung besprechen

[00:17:14] Ausbildung und Ausbilder:in bewerten

[00:18:26] Ansprechpersonen und Zeit für Betreuung

[00:20:13] Interesse, Antworten und verständliche Erklärungen

[00:22:15] Fachliche und soziale Kompetenz

[00:23:00] Roter Faden und sinnvolle Aufgaben

[00:24:14] Freiraum und passende Schwierigkeit

[00:26:08] Schule und Betrieb miteinander verbinden

[00:28:09] Arbeitsklima und Einbindung ins Unternehmen

[00:30:51] Regelmäßige Gespräche und Erfahrungsaustausch

Evaluierungsbögen

Meine Evaluierungsbögen kannst du hier in Form von PDF-Dateien herunterladen.

Wenn du sie als editierbare Word-Dateien* herunterladen möchtest, melde dich einfach für meinen Newsletter an. Dann bekommst du direkt den entsprechenden Download-Link.

Selbstevaluierung des Azubis

Evaluierung des Azubis

Evaluierung des Ausbilders

Literaturempfehlungen

Das Konzept der One-on-Ones habe ich aus dem Manager Tools Podcast, den ich bereits seit vielen Jahren verfolge. Kürzlich sind die zentralen Inhalte der Ansätze von Manager Tools auch als Buch The Effective Manager* erschienen, das ich sehr empfehlen kann. Es fasst auf ein paar hundert Seiten die wichtigsten Aussagen von über 10 Jahren Podcast zusammen.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Bewertung von Auszubildenden (Evaluierungsbögen) - Anwendungsentwickler-Podcast #71

Zusammenfassung

Wie ich die Gespräche organisiere

Für das wöchentliche Einzelgespräch nehme ich mir eine halbe Stunde Zeit. Alle sechs Monate kommt ein längeres Gespräch hinzu, für das du und ich Bewertungsbögen ausfüllen. Die einzelnen Kriterien sind jeweils mit einem kurzen Satz erläutert.

Du schätzt deine Arbeit selbst ein, während ich dieselben Kriterien aus meiner Perspektive bewerte. Anschließend gehen wir jeden Punkt durch und begründen, wie wir zu unserer Einschätzung gekommen sind. Dadurch lernst du, deine eigene Arbeit und ihre Wirkung auf andere besser einzuordnen. Meine Erfahrungen mit anderen IT-Azubis im jeweiligen Ausbildungsjahr helfen beispielsweise dabei, deinen Zeitbedarf einzuschätzen.

Mein Bogen enthält die gleichen Fragen zum Ankreuzen wie deiner. Die offenen Fragen stehen auf deinem Bogen.

Welche Kriterien ich bei dir bewerte

Umgang mit Menschen

Im Team zusammenarbeiten: Dazu gehört, dass du offen und freundlich mit deinen Kolleg:innen umgehst. Auch alltägliche Dinge wie Begrüßen und Verabschieden fließen ein.

Mit Konflikten und Feedback umgehen: Rückmeldungen zu deinem Code helfen dir beim Lernen. Entscheidend ist, wie du darauf reagierst und ob du Hinweise annimmst.

Aufgaben sorgfältig und rechtzeitig erledigen

Gute Arbeit abliefern: Du prüfst deine Ergebnisse und holst dir Feedback dazu, ob du deine Aufgabe richtig gelöst hast.

An schwierigen Aufgaben dranbleiben: Ich schaue darauf, wie ausdauernd du arbeitest, wenn Probleme auftreten.

Deinen Zeitbedarf einschätzen: Du bekommst Rückmeldung dazu, ob die benötigte Zeit zu deiner Aufgabe und deinem Ausbildungsstand passt. Das hilft dir auch mit Blick auf die Abschlussprüfung.

Termine einhalten: Dazu gehört, wichtige Aufgaben vorzuziehen, wenn ein Termin näher rückt. Überstunden werden im Gespräch als Beispiel erwähnt; gewünscht sind sie in meinem Betrieb grundsätzlich nicht.

Dich aktiv einbringen

Eigenständig Aufgaben finden: Du schaust, wo Arbeit anfällt, und bietest Kolleg:innen deine Hilfe an, etwa wenn in einer Besprechung ein Problem auftaucht.

Selbstständig arbeiten: Mit zunehmender Erfahrung kannst du mehr Aufgaben eigenständig lösen. Wenn du festhängst, frag nach. Gerade im ersten Ausbildungsjahr helfen dir Fragen dabei, weiterzukommen; bei einfachen Grundlagen ist eine kurze Nachfrage sinnvoll.

Mitdenken und Abläufe hinterfragen: Bei wiederkehrenden Aufgaben kannst du prüfen, ob sie sich automatisieren lassen. Auch etablierte Abläufe verdienen einen Blick darauf, ob sie sinnvoll sind.

Zuverlässig sein: Ich bewerte, ob auf dich bei deinen Aufgaben Verlass ist.

Gelegentlich unangenehme Aufgaben übernehmen: Im Arbeitsalltag fallen auch weniger interessante Tätigkeiten an. Dabei zählt, wie du mit ihnen umgehst. Deine Ausbildung soll dir zugleich die fachlichen Inhalte vermitteln.

Aus eigenem Interesse dazulernen: Fachbücher und Blogartikel geben dir Gelegenheit, dich selbstständig mit Themen zu beschäftigen. In meiner Abteilung stehen dafür Bücher bereit, beispielsweise Clean Code und The Pragmatic Programmer. Zusätzlich organisiere ich Buchclubs.

Zusammenhänge verstehen und Probleme lösen

Über deinen Aufgabenbereich hinausblicken: Du berücksichtigst, welche Folgen deine Arbeit für andere Bereiche oder Kolleg:innen hat. Änderungen an zentralen Funktionen können mehrere Teile eines Systems betreffen.

Neues verstehen: Ich schaue darauf, wie schnell du Lerninhalte und Aufgaben erfassen und umsetzen kannst.

Kreative Lösungen finden: Dafür brauchst du Kenntnisse über verschiedene Lösungswege. Dieses Kriterium lässt sich gegen Ende der Ausbildung besser beurteilen, wenn du bereits mehr Grundlagen kennst.

Schwierige Probleme lösen: Du denkst zunächst selbst über einen Lösungsweg nach und holst dir Hilfe, wenn du sie brauchst. Wie selbstständig du dabei vorgehst, hängt auch von deinem Ausbildungsstand ab.

In der Berufs- oder Hochschule vorankommen: Hier fließen deine Noten ein. Die Hochschule ist berücksichtigt, weil ich auch duale Student:innen betreue.

Im Betrieb dazulernen: Ich ordne deine Kenntnisse danach ein, was zum jeweiligen Zeitpunkt deiner Ausbildung zu erwarten ist. Diesen Bereich bewerte ich separat von deinen schulischen Leistungen.

Aufgaben planen und eigene Ideen beitragen

Beim Programmieren zerlegst du größere Probleme in kleinere Aufgaben und gehst diese systematisch an. Schon bei frühen Übungen zeigt sich, wie du deinen Code strukturierst. Für dein Abschlussprojekt brauchst du diese Fähigkeit ebenfalls, damit du die verfügbare Zeit sinnvoll einteilen kannst.

Aus der Berufsschule oder eigenen Projekten bringst du Erfahrungen mit, die für den Betrieb interessant sein können. Ich möchte, dass du solche Ideen ansprichst, etwa wenn du zu Hause eine andere Programmiersprache ausprobiert hast. Gerade zum Ende der Ausbildung erwarte ich, dass du eigene Vorschläge einbringst.

Wie du meine Arbeit und deine Ausbildung bewertest

Auf einem weiteren Bogen gibst du mir Feedback zur Qualität deiner Ausbildung. Beim Ankreuzen steht das mittlere Smiley für den erwarteten Standard. Ein lachendes Smiley kennzeichnet etwas, das positiv auffällt; ein trauriges zeigt, wo etwas verbessert werden sollte.

Wie ich dich betreue

Neben deinem allgemeinen Eindruck von der Ausbildung bewertest du folgende Punkte:

Ansprechpersonen und Zeit: Du brauchst jemanden, der dir weiterhilft und Zeit für deine Fragen hat. Wenn ich abwesend bin, können auch erfahrene Kolleg:innen diese Aufgabe übernehmen und dir weitere Perspektiven zeigen.

Interesse an deiner Arbeit: Du beurteilst, ob ich mich mit deinen Aufgaben und Ergebnissen beschäftige.

Auf Fragen eingehen: Zu einer Frage gehört eine nachvollziehbare Antwort. Wenn gerade wenig Zeit ist, sollte ich später darauf zurückkommen und die Hintergründe erläutern.

Verständlich erklären: Du sollst nachfragen können, bis du verstanden hast, warum etwas auf eine bestimmte Weise funktioniert.

Fachlich kompetent sein: Du bewertest, ob ich mich mit den Themen auskenne, die ich dir vermittle.

Mit Menschen umgehen können: Auch wie ich mit dir spreche und Wissen vermittle, gehört auf den Bogen.

Wie deine Ausbildung abläuft

Ein nachvollziehbarer roter Faden: Die Inhalte sollten aufeinander aufbauen, sodass du die nötigen Grundlagen für deine Aufgaben kennst.

Sinnvolle Aufgaben: Echte Projekte geben dir Gelegenheit, etwas zum Betrieb beizutragen.

Freiraum beim Arbeiten: Du brauchst Zeit und Spielraum, um dich selbstständig mit einer Aufgabe auseinanderzusetzen.

Passende Schwierigkeit: Aufgaben sollten etwas über deinen aktuellen Fähigkeiten liegen, sodass du dazulernst und sie bewältigen kannst. Dabei orientiere ich mich am beschriebenen Flow-Zustand. Dein Feedback hilft mir, den Ausbildungsplan oder die Projekte anzupassen.

Berufs- oder Hochschule und Betrieb verbinden: Du beurteilst, wie sich die Inhalte aus dem Unterricht auf deine Arbeit übertragen lassen. Ich kann den Ausbildungsplan darauf abstimmen. In meinem Betrieb beginne ich früh mit dem Programmieren, wodurch manche Grundlagen später im Unterricht erneut vorkommen.

Wie du dich im Betrieb fühlst

Beim Arbeitsklima bewertest du, wie du den täglichen Umgang erlebst und ob du dich akzeptiert fühlst. Außerdem schaust du separat darauf, wie gut du in das Unternehmen und in deine Abteilung eingebunden bist.

Zum Unternehmen gehört,...

Die Evaluierung von Auszubildenden und Ausbildern ist Thema der einundsiebzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Mit wöchentlichen One-on-Ones und halbjährlichen Evaluierungsgesprächen begleite ich dich durch die IT-Ausbildung. Dabei sprechen wir über deine Arbeit und darüber, wie du dich fachlich weiterentwickelst. Du schätzt deine Fähigkeiten selbst ein, bekommst Feedback zu deinen Stärken sowie zu Lernlücken und gibst mir Rückmeldung zu meiner Arbeit als Ausbilder. Dafür verwende ich Fragebögen mit offenen Fragen und einer einfachen Smiley-Skala.

Kapitelmarken

[00:00:01] Einstieg: Leistung von IT-Azubis bewerten

[00:01:16] One-on-Ones und Anregungen von Manager-Tools

[00:04:45] Halbjährliche Evaluierungsgespräche im Überblick

[00:05:44] Feedback für IT-Azubis und Ausbilder:innen

[00:07:39] Fragebögen überarbeiten und Erfahrungen austauschen

[00:09:03] One-on-Ones: Ablauf und freie Themenwahl

[00:11:06] Zeit für deine Anliegen und mein Feedback

[00:13:24] Nächste Aufgaben und Lernschritte besprechen

[00:13:56] Wöchentliche Termine ab Ausbildungsbeginn

[00:14:59] Evaluierungsgespräche mit drei Fragebögen

[00:16:03] Bisherige Aufgaben und Erfahrungen reflektieren

[00:17:36] Wünsche für kommende Themen und Projekte

[00:18:59] Hilfreiche Erfahrungen und vorhandene Kenntnisse

[00:20:34] Lernlücken erkennen und passende Förderung finden

[00:22:34] Ziele priorisieren und persönliche Anliegen ansprechen

[00:24:12] Kriterien mit einer Smiley-Skala bewerten

[00:25:33] Bögen aufbewahren und den Ausbildungsverlauf festhalten

[00:26:04] Bereiche der Bewertung und Ausblick auf die Fortsetzung

[00:26:26] Evaluierungsbögen herunterladen und anpassen

[00:27:14] Quellenangaben in der Projektpräsentation

[00:27:56] Empfehlungen zu Domain-Driven Design

[00:28:39] Fortsetzung mit den einzelnen Bewertungskriterien

Inhalt

Ich führe wöchentlich halbstündige Gespräche (O3 = One-on-Ones) mit jeder/m Auszubildenden.

10 Minuten für die/den Azubi/ne, 10 Minuten für mich, 10 Minuten für die Zukunftsplanung.

In halbjährlichen Evaluierungsgesprächen gehen wir alle bisherigen Aufgaben des Azubis durch, besprechen Wünsche bzgl. zukünftiger Aufgaben, sprechen über evtl. vorhandene Lernschwierigkeiten und wie sie behoben werden können, Probleme mit Kollegen usw.

Auch die Bewertung des Ausbilders ist Bestandteil dieses Gesprächs, damit beide Seiten etwas lernen können.

Die Gespräche werden anhand eines Fragebogens mit offenen Fragen zur Ausbildung geführt, damit nichts vergessen wird und beide Seiten sich entsprechend vorbereiten können.

Im Anschluss schreibe ich dann ein kurzes Protokoll mit "ToDo-Listen", die als Grundlage für das nächste Gespräch dienen.

Durch die wöchentlichen Gespräche ist allerdings auch meist schon Vieles geklärt, sodass in den halbjährlichen Terminen eher langfristige Themen wie Prüfungsvorbereitung, potentielle Aufgaben nach der Ausbildung usw. behandelt werden.

Evaluierungsbögen

Meine Evaluierungsbögen kannst du hier in Form von PDF-Dateien herunterladen.

Wenn du sie als editierbare Word-Dateien* herunterladen möchtest, melde dich einfach für meinen Newsletter an. Dann bekommst du direkt den entsprechenden Download-Link.

Selbstevaluierung des Azubis

Evaluierung des Azubis

Evaluierung des Ausbilders

Literaturempfehlungen

Das Konzept der One-on-Ones habe ich aus dem Manager Tools Podcast, den ich bereits seit vielen Jahren verfolge. Kürzlich sind die zentralen Inhalte der Ansätze von Manager Tools auch als Buch The Effective Manager* erschienen, das ich sehr empfehlen kann. Es fasst auf ein paar hundert Seiten die wichtigsten Aussagen von über 10 Jahren Podcast zusammen.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

One-on-Ones Part 1 | Manager Tools

One-on-Ones Part 2 | Manager Tools

One-on-Ones Part 3 | Manager Tools

Zusammenfassung

Wöchentlich Zeit für ein persönliches Gespräch

Seit mehreren Jahren führe ich mit meinen IT-Azubis wöchentliche One-on-Ones, die jeweils eine halbe Stunde dauern. Die Idee stammt aus dem Podcast Manager-Tools. Solche Gespräche helfen dabei, einander kennenzulernen und eine gute Beziehung aufzubauen. In meinem Betrieb liegt die Rolle als Vorgesetzte:r bei der Abteilungs- beziehungsweise Bereichsleitung; ich begleite die Ausbildung als Ausbilder.

Obwohl ich mit meinen Auszubildenden im selben Büro sitze und Fragen auch im Alltag beantworten kann, reserviere ich jede Woche Zeit für ein Gespräch unter vier Augen. Damit beginne ich bereits in der ersten Ausbildungswoche. Meist liegt der Termin am gleichen Wochentag zur gleichen Uhrzeit. Wenn etwas Dringendes dazwischenkommt, lässt er sich verschieben, wobei der wöchentliche Austausch verlässlich stattfinden soll.

So laufen die 30 Minuten ab

| Zeit | Inhalt |

| --- | --- |

| Erste zehn Minuten | Du bestimmst die Themen und sprichst beispielsweise über Fragen zu deinen Projekten oder über etwas aus deinem Privatleben. |

| Zweite zehn Minuten | Ich gebe dir Feedback zu deiner Arbeit und bringe eigene Themen ein. Auch Persönliches kann hier Platz haben. |

| Letzte zehn Minuten | Gemeinsam besprechen wir, welche Aufgaben bis zur nächsten Woche anstehen und worauf du beim Lernen deinen Schwerpunkt legst. |

Die Zeitblöcke geben einen Rahmen vor. Wenn du länger erzählen möchtest, bekommt dein Anliegen mehr Raum innerhalb der halben Stunde. Der gesamte Termin bleibt bei 30 Minuten.

Welche persönlichen Dinge du ansprichst, entscheidest du selbst. In meiner Praxis drehen sich die Gespräche überwiegend um die Arbeit, weil sich im Büroalltag bereits viele Gelegenheiten ergeben, über andere Themen zu sprechen. Am Ende geht es etwa um kommende Projekte oder um Technologien, die du dir als Nächstes anschaust.

Etwa jedes halbe Jahr genauer auf die Ausbildung schauen

Zusätzlich führe ich ungefähr alle sechs Monate ein längeres Evaluierungsgespräch. Dafür habe ich folgende Bögen zusammengestellt:

Einen Bogen, auf dem du deine Arbeit und deine Fähigkeiten selbst einschätzt.

Einen entsprechenden Bogen, auf dem ich dir Feedback gebe.

Einen weiteren Bogen, mit dem du meine Arbeit als Ausbilder bewertest.

Zu Beginn gehen wir deine Selbsteinschätzung durch. Offene Fragen beantwortest du mit eigenen Worten. Anschließend sprechen wir über die einzelnen Punkte und gleichen unsere Einschätzungen ab.

Durch regelmäßiges Feedback kannst du besser einschätzen, wie weit du fachlich bist und wo du noch lernen musst. Dazu gehört auch die Frage, ob deine Kenntnisse für die Prüfung ausreichen. Deine Stärken verdienen ebenso Aufmerksamkeit, weil sie Hinweise darauf geben, welche Aufgaben später zu dir passen.

Diese offenen Fragen beantwortest du

Bisherige Aufgaben und eigene Interessen

Was hast du seit dem letzten Gespräch gemacht und gelernt? Du schaust auf die vergangenen Monate zurück und hältst fest, welche Themen dir begegnet sind.

Was ist dir positiv in Erinnerung geblieben und soll beibehalten werden? Hier kannst du beschreiben, welche Aufgaben dir gefallen haben.

Welche Erfahrungen waren negativ und was soll sich ändern? Dabei geht es auch darum, welche Tätigkeiten du später übernehmen möchtest.

Welche Themen oder Aufgaben wünschst du dir für die Zukunft? Deine Interessen fließen ein, wenn ich Projekte verteile. Der Ausbildungsplan und die verfügbare Zeit bestimmen mit, welche Wünsche sich umsetzen lassen.

Was dir beim Arbeiten hilft und wo du Unterstützung brauchst

Was hat deinen Erfolg gefördert oder erschwert? Du hältst fest, was dir bei Projekten geholfen hat und wo du auf Schwierigkeiten gestoßen bist, etwa bei einem Programmierkonzept oder einem Werkzeug.

Welche Kenntnisse und Fähigkeiten konntest du einbringen? Dabei kannst du auch überlegen, wo Wissen aus der Berufsschule oder aus deiner bisherigen Schulzeit in deiner Arbeit vorkam.

Wo fehlen dir Kenntnisse oder fällt dir das Lernen im Betrieb schwer? Deine eigene Einschätzung ergänze ich durch mein Feedback. Daraus ergeben sich passende nächste Lernschritte.

Welche Tätigkeiten passen zu deinen Fähigkeiten? Du überlegst, in welchen Aufgabenbereichen du deine Stärken einbringen kannst und woran du gern arbeitest.

Was würde dir beim Lernen helfen? Hier kannst du beispielsweise Bücher oder gezielte Übungsaufgaben vorschlagen. Auch Code Reviews kommen infrage.

Nächste Schritte und persönliche Anliegen

Welche künftigen Aufgaben oder Ziele sind dir besonders wichtig? Deine Antwort hilft mir, bei mehreren möglichen Projekten einen Schwerpunkt zu setzen.

Gibt es Konflikte mit Mitarbeiter:innen oder Vorgesetzten? Im Gespräch unter vier Augen kannst du solche Schwierigkeiten ansprechen und Unterstützung beim Umgang damit bekommen.

Hast du eigene Fragen? Hier ist Platz für Anliegen, die der Bogen bisher offenlässt.

Feedback mit einer Smiley-Skala

Für einzelne Kriterien verwende ich eine einfache Skala. Ein lachender Smiley steht für etwas, das positiv auffällt. Der neutrale Smiley bedeutet, dass alles in Ordnung ist. Mit dem traurigen Smiley kennzeichne ich einen Bereich, in dem du etwas verbessern solltest.

Zu jedem Punkt gehört das Gespräch darüber, was bereits gut läuft und woran du konkret weiterarbeiten kannst. Die Kriterien sind folgenden Bereichen zugeordnet:

Umgang mit Menschen

Leistungsmotivation

Engagement

Geistige Tätigkeiten

Planung und Organisation

Die detaillierten Unterpunkte sowie die Fragen zur Bewertung meiner Arbeit als Ausbilder folgen in der nächsten Episode.

Aus den Bögen verfasse ich etwa einmal pro Halbjahr einen kurzen Text, der den Ausbildungsverlauf festhält. Die ausgefüllten Bögen bewahre ich bei mir im Schrank auf. Für das schriftliche Protokoll dienen sie als Anhaltspunkte; die Personalakte enthält diese Bögen nicht.

Vorlagen und ergänzende Quellen

Meine Fragebögen habe ich aus verschiedenen Vorlagen und Anregungen von Manager-Tools zusammengestellt. Über die Jahre habe ich sie überarbeitet und Fragen entfernt, die sich in meinem Alltag kaum beantworten ließen. Du kannst mir eigene Erfahrungen oder Vorschläge pe