IT-Berufe-Podcast

Es wird Zeit für den ersten Buchclub im Anwendungsentwickler-Podcast. Und welches Buch wäre besser geeignet als das Handbuch für Fachinformatiker? Daher besprechen wir in der dreiundfünfzigsten Episode die ersten zwei Kapitel des Buchs.

TL;DR

Ich gehe mit dir die ersten beiden Kapitel des Handbuchs für Fachinformatiker:innen von Sascha Kersken durch und ordne die Inhalte anhand meiner bisherigen Prüfungserfahrungen ein. Für deine Ausbildung brauchst du logische Grundlagen und Mengenlehre, die du beim Programmieren und in SQL anwendest. Beim Rechnen in Prüfungen kommen Zahlensysteme sowie Angaben zu Speichergrößen und digitalen Medien hinzu. Die Kapitel behandeln außerdem die Geschichte der Informatik und technische Grundlagen bis zur Turing-Maschine.

Kapitelmarken

[00:00:00] Einstieg in den Buchclub zum IT-Handbuch

[00:02:00] IT-Berufe und gemeinsame Prüfungsgrundlagen

[00:04:39] Geschichte der Computer

[00:05:49] Entwicklung und Eigenschaften von Programmiersprachen

[00:07:34] Logisches Programmieren mit Prolog

[00:09:16] FORTRAN und COBOL in bestehenden Systemen

[00:10:06] Abwärtskompatibilität von C++ und Smalltalk

[00:11:33] Analoge und digitale Informationen

[00:13:40] Farbtiefe, Audioqualität und Speicherbedarf

[00:15:12] Zeichensätze und fehlerhafte Umlaute

[00:15:54] Aussagenlogik beim Programmieren

[00:17:10] Mengenlehre als Grundlage für SQL

[00:18:58] Zahlensysteme in Prüfung und Praxis

[00:20:44] Maßeinheiten und binäre Vorsilben

[00:22:23] Zweierpotenzen und typische Bitlängen

[00:25:17] Elektronische Grundlagen und Schaltungen

[00:26:18] Automaten und Laufzeit von Algorithmen

[00:28:52] Turing-Maschine und virtueller Prozessor

[00:29:59] Rückmeldungen zu den ersten beiden Kapiteln

[00:32:07] Nächster Buchclub zu Hardware und Netzwerken

[00:33:06] Scrum-Broschüre und Animationen in Projektpräsentationen

[00:33:46] Ausblick auf die Lernzielkontrolle zu Java EE 7

Inhalt

IT-Berufe und Studienrichtungen, Aufbau und Ablauf der Abschlussprüfung

Guter Überblick zum Einstieg. Man sollte die Berufe kennen.

Geschichte der Computer

Für mich eine spannende Zeitreise. Für die Prüfung irrelevant.

Entwicklung der Programmiersprachen

Das ist unser Brot und Butter :-)

Man sollte kennen/erklären können: Maschinencode, Assembler, Fortran, Cobol, Basic, C, imperative/prozedurale Programmierung, Smalltalk, C++, Java, C#, LISP, Prolog

Was bedeutet Abwärtskompatibilität bei C++?

C-Code ist auch gültiger C++-Code.

Wo wird Smalltalk in der Praxis eingesetzt?

Nirgends ;-)

Was sind Beispiele für logische Programmierung?

Prädikatenlogik in Prolog.

Digitale Speicherung und Verarbeitung von Informationen

Unterschied analog/digital wird gut erklärt.

Für die Prüfung sollte man übliche Farbtiefen und Sampling-Raten und -Tiefen kennen.

Zeichensätze werden nur kurz behandelt, kommen später aber noch einmal. Siehe auch Zeichensätze und -kodierung.

Einführung in die Logik

Wichtiges Kapitel für alle Informatiker. Wenig direkt prüfungsrelevant, sondern Transferwissen.

Wofür brauchen wir die Mengenlehre?

SQL macht nichts anderes als Mengenoperationen.

Informationsspeicherung im Computer

Wo braucht man die unterschiedlichen Zahlensysteme in der Praxis?

Dual: Subnetting, Oktal: Linux-Dateirechte, Hex: MAC-Adresse

Die Vorsilben der Maßeinheiten muss man auswendig kennen.

Welche Zweierpotenzen sollte man auswendig können?

1-10, 16, 24, 32, 48, 64, 128

Elektronische Grundlagen

Nett zu wissen, aber für die Prüfung eher unwichtig.

Automatentheorien und -simulationen

Komplexität ist ein wichtiges Thema für die Praxis, aber für die Prüfung irrelevant.

Auch die Turing-Maschine sollte jeder Informatiker kennen, aber in der Prüfung wird sie eher nicht Thema sein.

Der virtuelle Prozessor verdeutlicht gut verständlich die Abläufe in einer CPU.

Allgemeines Feedback zum Buch

Der Autor erzählt sehr persönlich. Man fühlt sich als Leser angesprochen.

Roter Faden in Kapitel 2 fehlt ein wenig.

Komplexität und elektrische Schaltungen waren schwer zu verstehen.

Nächster Buchclub: 04.04.2016, Kapitel 3 (Hardware) und 4 (Netzwerkgrundlagen)

Literaturempfehlungen

Na was wohl? ;-)

*(direkt beim Rheinwerk-Verlag bestellen*)

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

1 Einführung

2 Mathematische und technische Grundlagen

Zusammenfassung

Die ersten beiden Kapitel im Buchclub

Für den ersten Buchclub habe ich mit meinen IT-Azubis die ersten rund 100 Seiten des Handbuchs für Fachinformatiker:innen von Sascha Kersken gelesen. Dazu gehören die Einführung sowie die mathematischen und technischen Grundlagen. Meine Hinweise zu Prüfungen beruhen auf den Aufgaben, die ich bis zu dieser Folge kennengelernt habe.

IT-Berufe und gemeinsame Grundlagen

Als Fachinformatiker:in für Anwendungsentwicklung programmierst du Software. In der Systemintegration gehören vor allem Aufgaben als Administrator:in dazu, etwa Software einzurichten und zu konfigurieren.

IT-Systemelektroniker:innen kümmern sich um Hardware und Verkabelung. Zu ihrem Beruf gehören auch elektrotechnische Arbeiten.

Die im Buch beschriebenen kaufmännischen Berufe ordne ich grob so ein: Informatikkaufleute kümmern sich beispielsweise um den Einkauf von IT-Ausstattung, während IT-Systemkaufleute Kund:innen beraten und IT-Produkte verkaufen. Im Berufsalltag können sich diese Aufgaben überschneiden.

In der damals behandelten schriftlichen Prüfung Ganzheitliche Aufgabe 2 kommen gemeinsame Grundlagen verschiedener IT-Berufe vor. Als angehende:r Anwendungsentwickler:in kannst du deshalb auch Aufgaben zur strukturierten Verkabelung bekommen.

Das Buch stellt außerdem Studienrichtungen und den Ablauf der IHK-Abschlussprüfung vor. Der Überblick über die Berufe gehört zum Allgemeinwissen rund um deine Ausbildung.

Computergeschichte und Programmiersprachen

Die Geschichte der Computer führt unter anderem über Röhrenrechner bis zum C64, meinem ersten Computer. Historisches Wissen hilft dir, die Herkunft heutiger Ideen zu verstehen. Beispielsweise greifen heutige Sprachen Konzepte der funktionalen Programmierung aus den 1950er-Jahren auf. Fragen nach historischen Jahreszahlen gehören nach meinen bisherigen Erfahrungen kaum zu den Prüfungsaufgaben.

Das Buch beschreibt, wie sich Programmiersprachen entwickelt haben, angefangen bei Maschinencode und Assembler. Als Entwickler:in solltest du die Eigenschaften verschiedener Sprachen kennen, damit du eine passende Sprache für deine Aufgabe auswählen kannst.

C arbeitet prozedural; C# unterstützt objektorientiertes und teilweise funktionales Programmieren. Die Namen allein geben wenig Auskunft über die Eigenschaften einer Sprache.

Mit Prolog arbeitest du auf Basis von Fakten und Regeln. Aus einer Wissensbasis über Familienbeziehungen lassen sich beispielsweise verwandte Personen abfragen. Auch ein Sudoku lässt sich damit lösen. Bei diesem deklarativen Ansatz beschreibst du das gewünschte Ergebnis, ähnlich wie bei einer SQL-Abfrage.

FORTRAN und COBOL sind weiterhin in bestehenden Systemen vertreten. Gerade bei Banken und Versicherungen gibt es umfangreichen COBOL-Code, für den Entwickler:innen gebraucht werden.

Bei der im Buch beschriebenen Abwärtskompatibilität von C++ zu C geht es darum, vorhandenen C-Code in C++ weiterzuverwenden und um Möglichkeiten wie Objektorientierung zu ergänzen.

Smalltalk wird als frühe konsequent objektorientierte Sprache vorgestellt. Mir ist aus meiner Praxis kein Projekt bekannt, das damit arbeitet.

Analoge und digitale Informationen

Analoge Signale haben stetige Werte. Digitale Daten werden durch diskrete Werte dargestellt. Wenn ein gespeicherter Wert zwischen den verfügbaren Stufen liegt, muss er einer dieser Stufen zugeordnet werden, wodurch Genauigkeit verloren geht.

Bei digitalen Bildern solltest du übliche Farbtiefen kennen. Im Buch wird für JPEG-Bilder 24 Bit genannt. Solche Angaben können bei Aufgaben zum Speicherbedarf vorausgesetzt werden.

Für Audio in CD-Qualität brauchst du die Werte 44,1 Kilohertz Abtastrate, 16 Bit Abtasttiefe und üblicherweise zwei Tonkanäle für Stereo. Daraus lässt sich zusammen mit der Dauer der Speicherbedarf berechnen.

Auch grundlegende Geschwindigkeiten von Übertragungsverfahren und Datenträgern können für Rechenaufgaben gebraucht werden. Genannt werden beispielsweise ISDN und DSL sowie die einfache Geschwindigkeit eines CD-ROM-Laufwerks.

Zeichensätze und Zeichencodes wie ASCII und Unicode begegnen dir beim Umgang mit Textdateien. Falsch dargestellte Umlaute sind ein typisches Problem. Dazu verweise ich auf eine eigene Podcastfolge; das Buch behandelt das Thema später ausführlicher.

Logik und Mengenlehre beim Programmieren

Für Bedingungen in deinem Code brauchst du Aussagenlogik. In Prüfungen wendest du dieses Wissen vor allem innerhalb von Programmieraufgaben an, etwa wenn du eine Fallunterscheidung für eine Prüfziffer brauchst. Arbeite das Kapitel so durch, dass du Bedingungen selbst nachvollziehen kannst.

Mengenlehre bildet eine Grundlage relationaler Datenbanken. Schnittmengen und Vereinigungsmengen begegnen dir in SQL wieder. Wenn du verstehst, welche Mengen eine Abfrage miteinander verknüpft, kannst du ihre Ergebnisse herleiten.

In den von mir betrachteten Prüfungen der vorhergehenden Jahre kam SQL regelmäßig vor, häufig als größere Aufgabe mit 25 Punkten. Die mathematischen Grundlagen helfen dir dabei, solche Aufgaben zu bearbeiten.

Zahlensysteme und Speichergrößen

Zwischen dem Dualsystem und anderen Zahlensystemen umzurechnen gehört zum Prüfungswissen. Für Subnetting rechne ich mit Dualzahlen, weil sich Netzanteile und die gesetzten Bits einer Subnetzmaske damit direkt erkennen lassen.

Das Oktalsystem begegnet dir bei Linux-Dateirechten. Hexadezimale Zahlen stehen beispielsweise in MAC-Adressen und IPv6-Adressen.

Ein Byte besteht aus acht Bit. Die Vorsilben für größere Datenmengen solltest du kennen und bei Aufgaben genau lesen: Kilo und Mega stehen für Potenzen von 1000; Kibi und Mebi stehen für Potenzen von 10

Für viele Auszubildende zählt das Führen des Ausbildungsnachweises - des Berichtshefts - nicht gerade zu den Lieblingstätigkeiten. Es wird also Zeit, sich in der zweiundfünfzigsten Episode des Anwendungsentwickler-Podcasts einmal eingehender mit ihm auseinanderzusetzen.

TL;DR

Mit deinem Berichtsheft hältst du fest, was du während deiner IT-Ausbildung gemacht und gelernt hast, und kannst bei Problemen deinen Ausbildungsverlauf belegen. Es gehört zu den Voraussetzungen für die Abschlussprüfung; eine Note bekommst du dafür nicht. Ich empfehle dir, deine Einträge regelmäßig während der Arbeitszeit zu schreiben und zeitnah von deinem/deiner Ausbilder:in unterschreiben zu lassen. Welche Form und Fristen für dich gelten, klärst du mit deiner zuständigen IHK; beim Schreiben kannst du zugleich mit LaTeX üben oder über deinen Lernfortschritt nachdenken.

Kapitelmarken

[00:00:01] Einstieg: Das Berichtsheft in der IT-Ausbildung

[00:01:32] Ausbildungsaufgaben nachweisen und sich absichern

[00:03:15] Gesetzliche Pflicht und Voraussetzungen für die Prüfung

[00:04:31] Während der Arbeitszeit schreiben und Berichte durchsehen lassen

[00:05:34] Sonderfälle: Externe Prüflinge und dual Studierende

[00:07:16] Vorlagen der IHK und eine Vorlage für LaTeX

[00:08:35] Inhalte aus Betrieb und Berufsschule

[00:09:25] Ausbildungsfremde Aufgaben festhalten und ansprechen

[00:10:25] Ausdruck, Mappe und handschriftliche Berichte

[00:12:26] Software wählen und Dateien sichern

[00:14:11] Mein Ablauf mit Wiki und LaTeX

[00:14:48] Wie ausführlich die Einträge sein sollen

[00:16:13] Berichte regelmäßig aktualisieren

[00:17:32] Nachträglich schreiben und unstimmige Angaben vermeiden

[00:18:55] Wie Prüfer:innen das Berichtsheft durchsehen

[00:19:15] Berichtsheft zur Prüfung vorlegen

[00:20:17] Digitale Abgabe und Fristen der IHK

[00:21:35] Folgen eines fehlenden Berichtshefts

[00:22:27] Das Berichtsheft und die Prüfungsnote

[00:23:33] Feste Termine für das Schreiben einplanen

[00:24:12] Sich absichern und für das Abschlussprojekt üben

[00:25:19] Sprachlich sorgfältig schreiben

[00:26:09] Mit Technik arbeiten und Abläufe automatisieren

[00:27:09] Über den eigenen Lernfortschritt nachdenken

[00:28:02] Erfolge im Berichtsheft festhalten

[00:29:08] Berichte zeitnah unterschreiben lassen

[00:30:19] Ideen für Blogbeiträge sammeln

[00:31:14] Tagesberichte aus erfassten Projektzeiten erzeugen

[00:32:28] Kontakt, Themenwünsche und Newsletter

[00:33:52] Ausblick auf den Buchclub zum IT-Handbuch

Inhalt

Von vielen Azubis wird das Berichtsheft als nervige Pflicht angesehen, aber es gibt auch einen konkreten Grund, warum es erforderlich ist. Und mit ein wenig Einsatz kann das Führen des Berichtshefts sogar Spaß machen.

Warum muss ich überhaupt ein Berichtsheft führen?

Laut § 43 (Zulassung zur Abschlussprüfung) des Berufsbildungsgesetzes (BBiG) "Berufsbildungsgesetz (BBiG)") gilt:

Zur Abschlussprüfung ist zuzulassen, [...] wer an vorgeschriebenen Zwischenprüfungen teilgenommen sowie vorgeschriebene schriftliche Ausbildungsnachweise geführt hat [...]

Das bedeutet, dass man nur zur Prüfung zugelassen wird, wenn man sein Berichtsheft ordnungsgemäß geführt hat. U.a. in § 7 (Berichtsheft) der Verordnung über die Berufsausbildung im Bereich der Informations- und Telekommunikationstechnik wird darüber hinaus das Berichtsheft für die IT-Berufe noch etwas genauer beschrieben:

Der Auszubildende hat ein Berichtsheft in Form eines Ausbildungsnachweises zu führen. Ihm ist Gelegenheit zu geben, das Berichtsheft während der Ausbildungszeit zu führen. Der Ausbildende hat das Berichtsheft regelmäßig durchzusehen.

Es gibt also eine eindeutige gesetzliche Regelung zum Berichtsheft. Und daran hat sich jeder Ausbildungsbetrieb, aber auch jeder Azubi zu halten. Wir schauen in der Prüfung auch durchaus in die Berichtshefte und nehmen Stichproben von den vermittelten Inhalten. Gerade bei etwas schlechteren Prüflingen ist häufig die Frage, ob der Ausbildungsbetrieb eine Mitschuld trägt. Und das lässt sich nur anhand der Ausbildungsinhalte nachweisen.

Und genau dieser wichtige Grund spricht auch aus Sicht des Prüflings für die korrekte Pflege des Berichtshefts. Es ist nämlich der einzige schriftliche Nachweis für ein Fehlverhalten des Ausbildungsbetriebs. Wenn der Ausbildende den Azubi drei Jahre lang nur Kaffee kochen lässt und das auch immer brav im Berichtsheft unterzeichnet hat, hat der Azubi später bei Problemen in der Abschlussprüfung die Möglichkeit, sich über das Ausbildungsunternehmen zu beschweren.

Natürlich sollte man nicht bis zur Abschlussprüfung damit warten. Also wenn im ersten Jahr außer einfachen Hilfstätigkeiten kein ausbildungsrelevanter Inhalt im Berichtsheft steht, wird es als Azubi Zeit, tätig zu werden und die zuständige IHK zu kontaktieren.

Wann sollte ich das Berichtsheft pflegen?

Ich kenne einige Azubis, die das Führen des Berichtshefts nicht so ernst nehmen, und teils kurz vor der Prüfung Nachtschichten einlegen, um ein Berichtsheft zu produzieren. Das würde ich definitiv nicht empfehlen! Zusätzlich dazu, dass damit der gesamte Sinn des Berichtshefts hinfällig wird, ist es auch einfach schwierig, sich Ausbildungsnachweise für drei Jahre aus den Fingern zu saugen. Und wenn man dann noch alle Nachweise mit dem gleichen Datum unterschreibt, macht man es dem Prüfungsausschuss leicht, den Schwindel zu erkennen.

Eine vernünftige Ausbilderin wird darauf achten, dass das Berichtsheft regelmäßig geführt wird und den notwendigen Qualitätsanforderungen genügt. Rechtschreibfehler usw. sollten also im Berichtsheft nicht auftauchen.

Auch sollte das Berichtsheft regelmäßig ausgedruckt und abgeheftet werden, damit nicht kurz vor der Prüfung die große Panik einsetzt oder man das Berichtsheft gar ganz vergisst. Damit hat man als Azubi auch regelmäßig eine Unterschrift des Ausbildenden und könnte sich ggfs. bei der IHK beschweren, wenn es Probleme gibt. Ein guter Ausbildungsbetrieb wird kein Problem damit haben, regelmäßig das Berichtsheft abzuzeichnen.

Was heißt nun regelmäßig? Das kommt wohl wieder einmal auf die IHK an. Bei der IHK Oldenburg (siehe Berichtsheft kaufmännisch) sind die Ausbildungsnachweise als Wochenprotokolle zu führen und einmal monatlich zu unterzeichnen. Das ist meiner Meinung nach auch sinnvoll, da man als Anwendungsentwickler ja durchaus länger an Projekten arbeitet und nicht täglich etwas zu berichten hat (z.B. "Heute habe ich eine Schleife programmiert."). Ich habe aber auch schon (dicke) Berichtshefte gesehen, die aus Tagesprotokollen bestanden.

Also: Informiere dich bei deiner IHK, wie das Berichtsheft zu führen ist. Normalerweise sollte dein Ausbildungsbetrieb das aber auch wissen.

In welcher Form sollte das Berichtsheft geführt werden?

Ich habe schon einige Berichtshefte gesehen, die handschriftlich geführt wurden. Ich finde allerdings das passt nicht so recht zu einem IT-Beruf. Außerdem ist das ein ziemlicher Aufwand. Ich würde also getippte Berichte empfehlen.

Natürlich könnte man nun eine Word-Datei anlegen - ggfs. auf Basis einer bestehenden Vorlage der IHK -, aber auch davon rate ich ab. Schließlich sind wir doch ITler! Also bevorzuge ich etwas modernere Methoden.

Ich empfehle, das Berichtsheft in einem Wiki oder einer Plain-Text-Datei (z.B. mit Markdown) mit Versionierung (z.B. mit Git) zu führen. Das erleichtert die Korrekturen und auch die Prüfung durch den Ausbilder. Im Firmenwiki kann der Ausbilder sich jederzeit ein Bild vom Stand des Berichtshefts machen und ggfs. schon Korrekturen einbringen. In Word-Dateien ist das einfach umständlicher.

Aus den Wiki-Texten kann man dann z.B. ein LaTeX-Dokument füllen und hat auf Knopfdruck ein perfekt gesetztes Berichtsheft. Meine Azubis haben das Ganze so schon umgesetzt.

Zusammenfassung

Warum muss ich überhaupt ein Berichtsheft führen?

Um dich gegenüber deinem Ausbildungsunternehmen abzusichern, falls du keine adäquate Ausbildung bekommst.

Bin ich verpflichtet, das Berichtsheft zu führen?

Ja. Das regelt §43 des BBiG:

Zur Abschlussprüfung ist zuzulassen, [...] wer an vorgeschriebenen Zwischenprüfungen teilgenommen sowie vorgeschriebene schriftliche Ausbildungsnachweise geführt hat [...]

Und die Verordnung über die Berufsausbildung im Bereich der Informations- und Telekommunikationstechnik sagt:

Der Auszubildende hat ein Berichtsheft in Form eines Ausbildungsnachweises zu führen. Ihm ist Gelegenheit zu geben, das Berichtsheft während der Ausbildungszeit zu führen. Der Ausbildende hat das Berichtsheft regelmäßig durchzusehen.

Ich bin dualer Student oder externer Prüfling. Muss ich auch ein Berichtsheft führen?

Externe Prüflinge müssen häufig kein Berichtsheft führen, sondern nur einen Praxisbericht schreiben.

Kannst du mir eine verbindliche Auskunft darüber geben, ob und wie ich mein Berichtsheft zu führen habe?

Nein. Das kann nur die für dich zuständige IHK.

Gibt es Vorlagen für das Berichtsheft?

LaTeX-Vorlage für das Berichtsheft

Ausbildungsnachweis für die Berufsausbildung, IHK Oldenburg

Was gehört ins Berichtsheft?

Die Tätigkeiten, die du im Rahmen deiner Ausbildung durchgeführt hast.

Was du gelernt hast.

Die Inhalte in der Berufsschule.

In welcher Form soll ich das Berichtsheft führen?

Am häufigsten sehe ich ausgedruckte DIN A4-Blätter in stabilen Schnellheftern aus Pappe*. Einige Prüflinge lassen ihr Berichtsheft sogar binden. Es gibt aber auch IHKen, die das Berichtsheft online haben möchten. Einige Prüflinge führen das Berichtsheft auch handschriftlich (davon würde ich aber abraten).

*

Wie soll ich das Berichtsheft technisch führen?

Mit einem Textverarbeitungsprogramm deiner Wahl, z.B. LaTeX, Word* oder einem simplen Texteditor. Auf jeden Fall so, dass du es später einfach in die von der IHK gewünschte Form bringen kannst.

Darf ich das Berichtsheft während der Arbeitszeit führen?

Ja (siehe oben).

Wie detailliert müssen die Einträge sein?

Meiner Meinung nach reichen Wochenprotokolle mit einer Auflistung der wichtigst

Softwareentwickler haben viel zu tun und stehen häufig unter Zeitdruck. Um die verfügbare Zeit optimal nutzen zu können, gebe ich in der einundfünfzigsten Episode des Anwendungsentwickler-Podcasts einige Tipps zum Thema Produktivität.

TL;DR

Mit meinen Tipps kannst du als IT-Azubi bei der täglichen Arbeit Zeit sparen und deinen Code leichter weiterentwickeln. Zehnfingersystem und Tastenkürzel helfen dir dabei, deinen Computer zügig zu bedienen, während passende Programme wiederkehrende Eingaben übernehmen. Beim Programmieren wählst du die Sprache passend zur Aufgabe und hältst deinen Code mit einfachen, wiederverwendbaren Lösungen übersichtlich. Für langfristig produktives Arbeiten gehören außerdem Git und gründliches Lernen dazu; automatisierte Tests sowie Build-Werkzeuge erleichtern dir wiederkehrende Abläufe.

Kapitelmarken

[00:00:20] Produktiver arbeiten im Alltag als Softwareentwickler:in

[00:01:54] Das Zehnfingersystem lernen

[00:05:26] Tipptraining mit TIPP10

[00:06:26] Den Computer mit der Tastatur bedienen

[00:08:11] Tastenkürzel lernen mit MouseFeed

[00:10:14] Eigene Tastenkürzel und MoreUnit

[00:11:47] Weniger eingeben mit CLCL

[00:13:13] Zugangsdaten mit KeePass eintragen

[00:14:34] Textbausteine und Makros mit AutoHotkey

[00:15:51] Texte mit Vi und Vim bearbeiten

[00:18:08] Vim Adventures und Practical Vim

[00:18:58] Texte in Markdown schreiben und mit Git versionieren

[00:20:47] Dateien mit Everything finden

[00:23:30] Die passende Programmiersprache wählen

[00:26:41] Statische und dynamische Typisierung

[00:27:20] Code mit Git versionieren

[00:28:02] In geeignete Werkzeuge und Lernangebote investieren

[00:31:39] Neue Technologien und Framework-Versionen kennenlernen

[00:33:12] Reguläre Ausdrücke für Textmuster

[00:34:07] Excel und Calc im Entwicklungsalltag

[00:35:12] Zeit zum gründlichen Lernen einplanen

[00:36:12] Mit anderen Softwareentwickler:innen austauschen

[00:37:44] DRY: Funktionen zentral ablegen

[00:38:29] KISS: Einfache Lösungen wählen

[00:39:29] YAGNI: Aktuelle Anforderungen umsetzen

[00:40:55] Automatisierte Tests und Regressionen

[00:42:31] Build-Abläufe automatisieren und Continuous Integration

[00:44:53] Rückblick auf die Tipps zum Programmieren

[00:46:03] Links und Buchempfehlungen

[00:47:16] Weitere Tipps und Blogartikel

[00:48:21] Newsletter und Buchclub zum Handbuch für Fachinformatiker:innen

Inhalt

Zeit sparen

Lerne das 10-Finger-System, z.B. mit Tipp10.

Nutze deine Tastatur* und nicht die Maus*.

Lerne die wichtigsten Shortcuts deiner Tools. In Eclipse hilft dir z.B. MouseFeed dabei.

Definiere dir eigene Shortcuts für häufig benötigte Funktionen, z.B. für ReRun Tests. Ggfs. brauchst du Tools wie MoreUnit dafür.

Vermeide zu tippen, wo immer es geht. Ich nutze dafür z.B. CLCL, KeePass und AutoHotkey (siehe auch Tools für Softwareentwickler).

Nutze Vim als Editor. Hiermit kannst du ihn spielerisch lernen: VIM Adventures.

Lerne ein einfaches Textformat, wie z.B. Markdown (siehe auch Warum ich Markdown liebe).

Verschwende keine Zeit mit der Suche nach Dateien. Everything ist die Antwort auf alle Fragen.

Produktiv programmieren

Verwende die beste Sprache für die Lösung deines Problems (statisch vs. dynamisch, Java vs. C#).

Verwende eine Versionsverwaltungssoftware wie Git.

Verwende die besten Tools, auch wenn sie Geld kosten, z.B. eine gute IDE.

Lerne neue Technologien.

Erfinde das Rad nicht ständig neu.

Neue Frameworks wie Java EE 7 erfordern (vielleicht) weniger Code.

Reguläre Ausdrücke lösen viele Probleme.

Excel* ist ein mächtiges Werkzeug für allerlei Aufgaben.

Nimm dir Zeit zum Lernen und lies auch gerne mal ein Buch, anstatt Dinge nur halb zu verstehen.

Tausche dich mit anderen Entwicklern aus, z.B. in Foren oder bei Offline-Treffen.

Befolge die zentralen Prinzipien der Softwareentwicklung.

DRY

KISS

YAGNI

Schreibe automatisierte Tests (siehe auch Test everything).

Automatisiere alles.

Literaturempfehlungen

Wenn du den Umgang mit dem besten Editor der Welt perfektionieren willst, lernst du am besten vom "Meister". Practical Vim* ist voll von direkt anwendbaren Tipps zum Umgang mit Vim.

*

Das Buch Pro Git* habe ich hier im Blog schon ein paar Mal empfohlen. Es hat mir beim Verständnis der Funktionsweise von Git sehr geholfen und ist voll mit praxisnahen Informationen.

*

Wenn dir die oben genannten Prinzipien der Softwareentwicklung noch nicht viel sagen, dann ist es Zeit für Clean Code*. Das Buch muss jeder Softwareentwickler gelesen haben.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Zusammenfassung

Im Alltag Zeit sparen

Für meine IT-Azubis gehört Zeit zum Lernen und Ausprobieren zur Ausbildung. Gegen Ende der Ausbildung, besonders vor der Abschlussprüfung, steigt der Zeitdruck. Auch im späteren Alltag als Softwareentwickler:in helfen eingeübte Handgriffe und passende Werkzeuge dabei, Aufgaben zügig zu erledigen.

Das Zehnfingersystem lernen

Wenn du täglich Code und andere Texte schreibst, lohnt es sich, das Zehnfingersystem zu beherrschen. Durch regelmäßiges Üben prägen sich die Wege zu den Tasten ein, sodass du beim Tippen auf den Bildschirm schauen kannst. Bereits eingeübte Gewohnheiten umzustellen braucht Zeit. Ich habe dafür mehrere Wochen täglich geübt.

Das kostenlose Programm TIPP10 beginnt mit der Grundstellung auf A, S, D, F sowie J, K, L, Ö. Weitere Zeichen kommen schrittweise hinzu. Für Softwareentwickler:innen gibt es Übungen mit Klammern und Sonderzeichen.

Ich empfehle dir, das übliche Tastaturlayout zu lernen. Damit kannst du auch beim Pair Programming oder an einem anderen Arbeitsplatz mit vertrauten Tasten arbeiten.

Programme mit der Tastatur bedienen

Probiere für eine Stunde oder einen Tag aus, deinen Computer über die Tastatur zu bedienen. Bei alltäglichen Aufgaben lassen sich viele Aktionen direkt per Tastenkürzel ausführen. Die Kontextmenütaste einer Windows-Tastatur öffnet das Rechtsklickmenü; mit Enter kannst du beispielsweise eine Suche abschicken.

Lerne vor allem die Kürzel für Funktionen, die du häufig aufrufst. In Eclipse unterstützt dich das Plugin MouseFeed dabei: Nach wiederholten Mausklicks auf eine Funktion zeigt es das passende Tastenkürzel an. Für häufig aufgerufene Funktionen ohne Kürzel regt es an, eines festzulegen.

Eigene Tastenkürzel lassen sich an deinen Arbeitsablauf anpassen. Ich habe mir beispielsweise eines zum erneuten Ausführen meiner Tests eingerichtet. Das Eclipse-Plugin MoreUnit ermöglicht außerdem, mit Strg+J zwischen einer Klasse und dem zugehörigen Test zu wechseln.

Wiederkehrende Eingaben abkürzen

Für Texte, die du immer wieder eingibst, empfehle ich dir diese Werkzeuge:

CLCL speichert mehrere Einträge der Zwischenablage. In meiner Konfiguration bleiben die letzten 30 kopierten Inhalte verfügbar. So kannst du mehrere Textstellen nacheinander kopieren und später einzeln einfügen.

KeePass verwaltet deine Zugangsdaten. Mit einem passenden Browser-Plugin lassen sich Benutzername und Passwort per Tastenkürzel eintragen und das Formular abschicken.

AutoHotkey ersetzt kurze Eingaben durch längere Texte, etwa eine Grußformel oder deine E-Mail-Adresse. Das kostenlose Programm kann auch Makros ausführen, die mehrere Tastendrücke und Eingaben verbinden.

Vi beziehungsweise Vim lernen

Mit Vi/Vim kannst du Texte mit wenigen Tastendrücken bearbeiten. Über H, J, K und L bewegst du dich durch den Text, während deine Hände nahe an der Grundstellung bleiben. Auch beim Ersetzen und Bearbeiten von Text helfen kurze Befehle.

Für den Einstieg brauchst du Übung, weil viele Tasten eigene Befehle auslösen. Ein Cheat Sheet hilft dabei, sie nachzuschlagen. Ich empfehle dir das Spiel Vim Adventures, um Befehle spielerisch kennenzulernen, sowie das Buch Practical Vim mit Beispielen für den Arbeitsalltag.

Texte in einem einfachen Format schreiben

Ich schreibe meine Texte in Markdown. Damit kannst du beispielsweise Überschriften und Listen direkt im Text kennzeichnen. Für Fettschrift setzt du jeweils zwei Sternchen vor und hinter die betreffende Stelle. Weitere einfache Textformate sind Textile und die MediaWiki-Syntax.

Solche Dateien lassen sich mit Git versionieren. Dadurch kannst du nachvollziehen, wie sich ein Text entwickelt hat, einzelne Änderungen vergleichen und frühere Stände wiederherstellen.

Dateien mit Everything finden

Das kostenlose Windows-Programm Everything erfasst Dateinamen auf deiner Festplatte. Anschließend kannst du Dateien durch Eingeben eines Namens schnell finden. Die hier beschriebene Suche arbeitet anhand der Dateinamen; die Inhalte der Dateien werden dabei nicht als Volltext erfasst.

Produktiv programmieren

Die Sprache passend zur Aufgabe wählen

Wenn du mehrere Programmiersprachen kennst, kannst du einschätzen, welche für deine Aufgabe geeignet ist. Dabei zählen auch die verfügbaren Bibliotheken und das Umfeld, in dem dein Programm laufen soll.

Für Skripte unter Windows empfehle ich PowerShell. Bei Office-Aufgaben kommt .NET infrage, während Erweiterungen für WordPress in PHP entstehen. Für dynamische Websites ist beispielsweise Ruby on Rails eine Möglichkeit.

Auch das Typsystem gehört zu dieser Entscheidung:

Mit dynamisch typisierten Sprachen lassen sich erste Lösungen mit wenig Code schreiben.

Statisch typisierte Sprachen ermöglichen Unterstützung durch die IDE, etwa beim Springen zu einer Typdefinition, und helfen beim langfristigen Weiterentwickeln des Codes.

Code mit Git versionieren

Mit Git kannst du Änderungen nachvollziehen und Unterschiede zwischen mehreren Ständen ansehen. Beim Ausprobieren hast du einen gespeicherten, funktionierenden Stand, zu dem du zurückkehren kannst. Git funktioniert auch lokal auf deinem Rechner.

Ich verwende Git für meinen Code und meine Texte. Als Buch zum Einstieg empfehle ich Pro Git, das auch kostenlos verfügbar ist.

Geeignete Werkzeuge und Lernangebote auswählen

Beziehe beim Kauf von Software die Zeit ein, die sie dir bei deiner Arbeit spart. Wenn du zwei Stunden suchst, um zehn Euro für ein geeignetes Programm einzusparen,...

Da ich gerade wieder einen Haufen Projektanträge für das Abschlussprojekt gelesen habe, geht es in der fünfzigsten Episode des Anwendungsentwickler-Podcasts um die häufigsten Fehler im Projektantrag und wie man sie als Prüfling vermeiden kann.

TL;DR

Aus meinen Erfahrungen als Prüfer zeige ich dir 14 häufige Fehler im Projektantrag: Damit dein Abschlussprojekt als Fachinformatiker:in Anwendungsentwicklung beurteilt werden kann, muss erkennbar sein, wie du methodisch vorgehst und welche technische Tiefe deine Aufgabe hat. Beschreibe das betriebliche Problem verständlich, benenne die geplanten Technologien und berücksichtige, ob sich das Projekt wirtschaftlich lohnt. Teile deine Projektzeit in konkrete Arbeitsschritte auf, beachte die Vorgaben deiner IHK und lass deinen Antrag vor dem Einreichen gegenlesen.

Kapitelmarken

[00:00:01] Thema: Häufige Fehler im Projektantrag

[00:00:20] 50. Episode und Erfahrungen mit aktuellen Projektanträgen

[00:02:07] Fehler 1: Lange Projektphasen genauer aufteilen

[00:04:34] Fehler 2: Methodisches Vorgehen erkennbar machen

[00:06:37] Fehler 3: Geplante Artefakte benennen

[00:08:38] Fehler 4: Wirtschaftlichkeit berücksichtigen

[00:10:28] Fehler 5: Programmiersprache und Technologien angeben

[00:12:27] Fehler 6: Technische Tiefe deutlich machen

[00:15:02] Fehler 7: Projektzeit vollständig und konkret verplanen

[00:17:26] Fehler 8: Projektphasen angemessen gewichten

[00:19:09] Fehler 9: Zeit für die Projektdokumentation begrenzen

[00:20:17] Fehler 10: Dokumentation für Anwender:innen und Entwickler:innen einplanen

[00:22:32] Fehler 11: Das betriebliche Problem verständlich beschreiben

[00:26:27] Fehler 12: Verständliche Sätze schreiben

[00:27:24] Fehler 13: Rechtschreibung und Grammatik prüfen

[00:29:20] Fehler 14: Sachlich und passiv formulieren

[00:30:37] Rückblick auf die 14 häufigsten Fehler

[00:33:42] Vertiefende Artikel in den Shownotes

[00:34:09] Bloghinweise zu Laserpointern und Java 8

[00:34:58] Aktualisierte Checkliste für den Projektantrag

[00:35:59] Ausblick: Produktivität für Softwareentwickler:innen

Inhalt

Lange Projektphasen von teils 40 Stunden werden nicht weiter runtergebrochen.

Eine methodische Softwareentwicklung wird nicht deutlich.

Zu erstellende Artefakte werden nicht genannt.

Die Betrachtung der Wirtschaftlichkeit wird vergessen.

Zu verwendende Programmiersprache und -plattform werden nicht genannt.

Die technische Tiefe wird nicht deutlich.

Die Projektzeit wird nicht exakt verplant (Puffer).

Die Zeitplanung ist nicht sinnvoll (Verhältnis passt nicht).

Die Problemstellung ist unverständlich.

Es wird zu viel Zeit für die Dokumentation eingeplant (teils 20 Stunden).

Benutzer- und/oder Entwicklerdokumentation werden nicht eingeplant.

Der Text ist schwer verständlich (z.B. ohne Einleitung mitten ins Thema einsteigen).

Der Text ist voller Rechtschreibfehler.

Der Prüfling schreibt in der Ich-Perspektive.

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Inhalte des Projektantrags

Ist die Projektdokumentation Teil der Bearbeitungszeit des IHK-Abschlussprojekts?

Wie viel Zeit sollte man für die Projektdokumentation einplanen?

Muss die Projektbearbeitungszeit (70 Stunden) wirklich genau eingehalten werden?

Die Wirtschaftlichkeit interessiert niemanden – Mythen der Projektpräsentation

Erzählperspektive der Projektdokumentation

Weitere Infos zum ProjektantragDu suchst noch mehr Tipps rund um den Projektantrag? Dann schau doch mal in diese Artikel- und Podcast-Kategorie: Alle Artikel rund um den Projektantrag.Und wenn du dich für meinen Newsletter einträgst, kannst du dir jetzt sofort meine Checkliste für den Projektantrag herunterladen.Jetzt anmelden!

Zusammenfassung

14 häufige Fehler im Projektantrag

Als Prüfer muss ich anhand deines Antrags einschätzen können, ob dein Projekt zum Berufsbild Fachinformatiker:in Anwendungsentwicklung passt und innerhalb der vorgesehenen Zeit machbar ist. Die Zeitbeispiele hier beziehen sich auf 70 Stunden Projektzeit. Meine Empfehlungen zu einzelnen Zeitansätzen sind persönliche Richtwerte; bei IHK-spezifischen Fragen gelten die Vorgaben deiner zuständigen IHK.

1. Lange Projektphasen genauer aufteilen

Wenn du 40 Stunden pauschal für das Programmieren einplanst, bleibt offen, welche Aufgaben du bearbeitest und wie du dabei vorgehst. Teile solche Phasen in konkrete Arbeitsschritte auf, damit sich der Aufwand fachlich beurteilen lässt. Mein Richtwert liegt bei höchstens acht Stunden pro Arbeitsschritt, also einem ganzen Arbeitstag.

2. Zeigen, wie du methodisch Software entwickelst

Beschreibe, mit welchen Methoden du deine Lösung planst. Bei einer Datenbank lässt sich beispielsweise ein Entity-Relationship-Modell vorsehen, während bei objektorientierter Software nachvollziehbar werden sollte, wie du Klassen und Architekturschichten entwirfst. Der Antrag muss erkennen lassen, dass du planvoll Software entwickelst und auf Qualität achtest.

3. Geplante Artefakte benennen

Über die Ergebnisse deiner einzelnen Arbeitsschritte wird dein Vorgehen greifbar. Nenne die Artefakte, die du im Projekt erstellen wirst. Je nach Aufgabe kommen beispielsweise infrage:

Lastenheft und Pflichtenheft

ER-Modell oder Tabellenmodell für die Datenbank

UML-Diagramme, etwa Use-Case-, Klassen-, Aktivitäts-, Zustands- oder Sequenzdiagramme

Architekturskizzen oder Paketdiagramme

Mock-ups für die Oberfläche

EPKs, Struktogramme oder Programmablaufpläne

Welche davon passen, ergibt sich aus deinem Projekt. Mit ihnen lässt sich erkennen, wie du Anforderungen und technische Zusammenhänge durchdenkst.

4. Prüfen, ob sich das Projekt wirtschaftlich lohnt

Zum Abschlussprojekt gehört ein Praxisbezug. Plane deshalb ein, Kosten und benötigte Ressourcen zu betrachten und den wirtschaftlichen Vorteil deiner Lösung zu prüfen. Dafür erwarte ich etwa zwei bis drei Stunden; eine Amortisationsrechnung sollte ergänzend berücksichtigt werden.

5. Die konkreten Technologien nennen

Gib an, welche Programmiersprache du einsetzt und auf welcher Plattform deine Anwendung laufen soll. Auch die Datenbank und eingesetzte Frameworks gehören in den Antrag. Diese Angaben helfen mir, den Aufwand einzuschätzen, weil ein Framework bestimmte Aufgaben bereits übernimmt und damit beeinflusst, wie viel Zeit du dafür brauchst.

6. Die technische Tiefe deutlich machen

Beschreibe deine Aufgabe so konkret, dass der fachliche Anspruch erkennbar wird. Dazu gehören technische Anforderungen und Angaben dazu, was du selbst entwickeln wirst. Das Projekt muss die berufsspezifischen Fähigkeiten zeigen, die nach einer dreijährigen Ausbildung erwartet werden. Bleibt der Umfang deiner eigenen Entwicklungsarbeit unklar, kann der Antrag abgelehnt werden.

7. Die gesamte Projektzeit konkret verplanen

Ordne die verfügbaren 70 Stunden vollständig konkreten Aufgaben zu. Pauschale Pufferzeiten halte ich für ungeeignet; einige IHKen verlangen allerdings einen Puffer, weshalb du ihre Vorgaben prüfen musst.

Auch pauschal reservierte Stunden für spätere Fehler werfen Fragen auf, solange Umfang und Art dieser Fehler unbekannt sind. Tests lassen sich bereits während der Entwicklung einplanen, beispielsweise als Unit-Tests.

8. Die Projektphasen angemessen gewichten

Wenn du zwei Stunden für die Analyse und 45 Stunden fürs Programmieren vorsiehst, fehlt aus meiner Sicht ausreichend Zeit, um die Anforderungen zu klären. Berücksichtige neben dem Implementieren auch Analyse und Entwurf sowie Qualitätssicherung und gegebenenfalls Abnahme. Die Zeitansätze müssen zum jeweiligen Aufwand passen. In einem Projekt zur Anwendungsentwicklung sollte das Implementieren den größten Anteil erhalten.

9. Für die Projektdokumentation angemessen viel Zeit vorsehen

Ob die bewertete Projektdokumentation innerhalb der 70 Stunden entstehen muss, hängt von deiner IHK ab. Prüfe das vorab. Falls sie zur Projektzeit zählt, empfehle ich etwa sieben bis acht Stunden dafür. Mehr als zehn Stunden halte ich bei diesem Projektumfang für zu viel.

10. Dokumentation für Anwender:innen und Entwickler:innen berücksichtigen

Plane diese Dokumente ein, sofern sie für dein Projekt sinnvoll sind. In vielen IHK-Bewertungsschemata werden sie separat bewertet.

Für ein überschaubares Handbuch mit Screenshots und kurzen Erläuterungen setze ich ungefähr drei bis vier Stunden an. Wenn die Dokumentation für Entwickler:innen aus bereits geschriebenen Quelltextkommentaren erzeugt wird, etwa mit Javadoc, rechne ich für das Erzeugen und Bereitstellen ungefähr eine halbe Stunde. Zusätzlicher Aufwand muss entsprechend berücksichtigt werden.

11. Das betriebliche Problem verständlich beschreiben

Führe so in dein Projekt ein, dass eine betriebsfremde Person den Zusammenhang versteht. Beschreibe dein Unternehmen und die relevante Infrastruktur, bevor du das Problem und das Projektziel erläuterst. Erkläre interne Produktnamen ebenso wie betriebsspezifische Fachbegriffe.

Lass eine Person außerhalb deines Unternehmens prüfen, ob sie versteht, worum es geht. Bei Kolleg:innen sind viele Begriffe bereits bekannt, sodass fehlende Erläuterungen beim Gegenlesen leicht übersehen werden.

12. Verständliche Sätze schreiben

Achte beim Überarbeiten darauf, ob verschachtelte Sätze oder unklare Einschübe den Text schwer lesbar machen. Auch fehlende Sätze können Zusammenhänge unterbrechen. Eine externe Person kann dir beim Gegenlesen zeigen, an welchen Stellen sie hängen bleibt. Wenn ich als Prüfer den Inhalt nicht nachvollziehen kann, lässt sich die Eignung des Projekts nicht beurteilen.

13. Sprachliche Fehler korrigieren lassen

Prüfe deinen Antrag auf Rechtschreibfehler und achte beim Gegenlesen auch auf Grammatik sowie Zeichensetzung. Falls dir das schwerfällt, hole dir Unterstützung, beispielsweise bei deinem/deiner Ausbilder:in oder einer anderen Person, die sprachlich sicher ist. Ein sorgfältig geprüfter Antrag vermittelt, dass du auf die Qualität deiner Arbeit achtest.

14. Den Antrag sachlich formulieren

Für technische Projekttexte empfehle ich eine neutrale, passive Schreibweise....

Nachdem beim letzten Mal das Erstellen des Entity-Relationship-Modells Thema war, widmen wir uns in der neunundvierzigsten Episode des Anwendungsentwickler-Podcasts den Schritten bei der Erstellung eines Tabellenmodells.

TL;DR

Ich zeige dir, wie du ein ER-Modell in ein relationales Tabellenmodell überträgst: Entitätstypen werden zu Tabellen, deren Spalten einen Datentyp erhalten und festlegen, ob NULL erlaubt ist. Bei 1:n-Beziehungen gehört der Fremdschlüssel auf die n-Seite; für m:n-Beziehungen legst du eine Zuordnungstabelle an. Für deine Prüfung gehören klar gekennzeichnete Schlüssel und die dritte Normalform dazu, während du bei zusammengesetzten Schlüsseln prüfen musst, ob sie jeden Datensatz eindeutig bestimmen.

Kapitelmarken

[00:00:01] Einstieg ins Tabellenmodell

[00:00:31] Relationale Datenbanken in Geschäftsanwendungen

[00:02:02] Tabellen, Relationen und Beziehungen

[00:03:36] Fremdschlüssel und Kardinalitäten

[00:04:54] Primärschlüssel und Fremdschlüssel kennzeichnen

[00:05:40] Spalten und Datentypen

[00:06:55] Datentypen für die Prüfung

[00:08:24] NULL und Pflichtfelder

[00:09:48] Tabellenmodelle zeichnen

[00:11:07] Vom ER-Modell zum Tabellenmodell

[00:12:14] Entitätstypen als Tabellen übernehmen

[00:14:11] 1:1-Beziehungen abbilden

[00:16:29] Fremdschlüssel bei 1:n-Beziehungen

[00:18:26] Zuordnungstabellen für m:n-Beziehungen

[00:19:51] Fachliche Namen für Zuordnungstabellen

[00:21:40] Zusammengesetzte Primärschlüssel

[00:22:18] Beziehungsattribute und wiederholte Zuordnungen

[00:24:05] Anonyme IDs als Primärschlüssel

[00:26:15] Schritte beim Übertragen im Überblick

[00:27:15] Zusätzliche Angaben in Prüfungsdiagrammen

[00:30:23] Dritte Normalform in der Prüfung

[00:31:28] Bewusst denormalisieren für schnellere Abfragen

[00:32:24] Prüfungsfrage zu Beziehungen und Normalformen

[00:33:32] Literatur und Übungsaufgaben

[00:35:26] Seven Databases in Seven Weeks

[00:36:23] Einzelprojekt und Teilprojekt beim Abschlussprojekt

[00:37:08] Erfahrungen aus der Spieleentwicklung

[00:37:55] Kontakt und Newsletter

[00:38:51] Ausblick auf Fehler im Projektantrag

Inhalt

Modellierung mit Tabellenmodellen

Welche Bestandteile hat ein Tabellenmodell?

Tabellen (Relationen) mit Name, Spalten, Datentypen; Beziehungen mit Kardinalitäten; Primär- und Fremdschlüssel werden gekennzeichnet (z.B. mit PK und FK).

Wie kommt man vom ER-Modell zum Tabellenmodell?

Jeder Entitätstyp wird zu einer Tabelle.

Attribute werden zu Spalten dieser Tabellen.

Datentypen der Spalten bestimmen.

m:n-Beziehungen durch Fremdschlüssel in Zwischentabellen auflösen. Ggfs. Attribute der Beziehung als Spalten ergänzen.

1:n- und 1:1-Beziehungen durch Fremdschlüssel auflösen.

Bei 1:1 ist die Position des Fremdschlüssels egal, bei 1:n muss er in die n-Tabelle.

Tipps zur Prüfung und Praxis

Immer alle Informationen einzeichnen, auch wenn sie nicht explizit gefragt sind.

Drei Datentypen reichen: VARCHAR, NUMBER und DATE.

Wenn eine Tabelle einen zusammengesetzten Schlüssel mit mehr als 2 Attributen hat, führe einen anonymen Primärschlüssel ein.

Achte auf ein normalisiertes Modell in dritter Normalform (die weiteren Normalformen sind irrelevant).

Du solltest trotzdem erklären können, wann man von der Normalisierung abweichen kann/sollte.

Die 1:n-Beziehungen werden in der 3. Normalform aufgelöst, die m:n-Beziehungen in der 2.

Literaturempfehlungen

Einsteigern ins Thema Datenmodellierung empfehle ich die Artikelreihe von Dr. Veikko Krypczyk im Entwickler Magazin. Der erste Artikel ist frei verfügbar: Datenbanken: Grundlagen und Entwurf - entwickler.de.

Im Handbuch für Fachinformatiker ist das komplette Kapitel 13 dem Thema Datenbanken gewidmet.

*(direkt beim Rheinwerk-Verlag bestellen*)

Am besten übst du die Datenbankmodellierung mit Prüfungsaufgaben der IHK. Dazu empfehle ich die Prüfungstrainer für die Abschlussprüfung*.

*

Ein tolles Buch, um einmal über den Tellerrand der relationalen Datenbanken hinweg zu schauen, ist Seven Databases in Seven Weeks*. Eine relationale Datenbank (PostgreSQL) wird vorgestellt, aber der Rest des Buches behandelt die unterschiedlichsten Typen von (NoSQL-)Datenbanken und ihre Besonderheiten - gerade auch ber der Datenmodellierung. Absolut lesenswert für jeden Softwareentwickler.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

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

Normalisierung - Häufige Fragen im Fachgespräch - Anwendungsentwickler-Podcast #18

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

Zusammenfassung

Tabellen und ihre Beziehungen

Als Fachinformatiker:in für Anwendungsentwicklung arbeitest du häufig an Geschäftsanwendungen, deren Daten in relationalen Datenbanken liegen. Beispiele aus dem Unternehmensumfeld sind Oracle und Microsoft SQL Server. Auch DB2 gehört dazu.

Eine Relation bezeichnet im Tabellenmodell eine Tabelle. Darin stehen zusammengehörige Daten, etwa die Attribute einer Person. Beziehungen zwischen Tabellen zeichnest du als Verbindungslinien ein und versiehst sie mit Kardinalitäten.

Im Tabellenmodell bilden Fremdschlüssel diese Beziehungen ab. Zu jeder Spalte gehört außerdem ein Datentyp, damit sich aus dem Modell eine lauffähige Datenbank erstellen lässt.

Was du in eine Tabelle einträgst

Eine Tabelle zeichnest du als Rechteck mit einem Namen. Für ihre Spalten hältst du folgende Angaben fest:

Spaltenname: Er ergibt sich aus dem jeweiligen Attribut.

Datentyp: Er legt fest, welche Werte die Spalte aufnehmen kann.

NULL erlaubt: Du kennzeichnest, ob ein Wert fehlen darf. Pflichtfelder erhalten NOT NULL.

Schlüssel: Mit PK für Primary Key markierst du den Primärschlüssel. FK steht für Foreign Key, also Fremdschlüssel.

Die Kürzel kannst du vor oder hinter die betreffende Spalte schreiben, solange eindeutig erkennbar bleibt, worauf sie sich beziehen. Für die Zeichnung reicht eine Verbindungslinie zwischen den Tabellen. Über die gekennzeichneten Schlüssel lässt sich zuordnen, welche Spalten zusammengehören.

Um eine Kardinalität einzutragen, formulierst du die Beziehung in beide Richtungen. Bei der Aussage "Eine Artikelgruppe enthält mehrere Artikel" steht das n an der Tabelle Artikel.

Datentypen für deine Prüfung

Da Datenbanksysteme unterschiedliche Typen anbieten, empfehle ich dir für Prüfungsaufgaben einfache Bezeichnungen, die dein:e Prüfer:in zuordnen kann:

VARCHAR für Zeichenketten, etwa einen Namen.

NUMBER für Zahlen, wobei du bei Bedarf Nachkommastellen angibst.

DATE für Datumswerte. Damit lassen sich auch Datumsoperationen ausführen, beispielsweise ein Jahr abziehen.

Wahrheitswerte kannst du bei fehlendem Boolean-Typ durch eine Zahl mit den Werten 0 und 1 abbilden. Bietet das Datenbanksystem einen passenden Boolean-Typ, kannst du diesen verwenden.

Vom ER-Modell zum Tabellenmodell

Entitätstypen übernehmen

Für jeden Entitätstyp legst du eine Tabelle an und überträgst dessen Attribute als Spalten. Den im ER-Modell unterstrichenen Primärschlüssel kennzeichnest du mit PK.

Anschließend vergibst du für jede Spalte einen Datentyp und entscheidest, ob NULL erlaubt ist. Ein Geburtsdatum erhält beispielsweise DATE; für einen Namen passt VARCHAR. Dieser Schritt lässt sich direkt aus dem ER-Modell ableiten und bringt dir bei einer entsprechenden Prüfungsaufgabe bereits Punkte.

1:1-Beziehungen abbilden

Bei einer 1:1-Beziehung kannst du den Fremdschlüssel in einer der beiden Tabellen unterbringen. Im Beispiel gehört zu einem Benutzerkonto genau ein Login, das wiederum genau diesem Konto zugeordnet ist.

Du kannst deshalb eine Login-ID in der Tabelle User hinterlegen oder eine User-ID in Login. Ich wähle den Ort danach, wie die Daten fachlich zusammengehören. Wenn das Benutzerkonto die Haupttabelle bildet und das Login ergänzende Daten enthält, lege ich die User-ID als Fremdschlüssel in Login ab.

1:n-Beziehungen abbilden

Bei einer 1:n-Beziehung kommt der Fremdschlüssel in die Tabelle auf der n-Seite. Jeder Artikel gehört im Beispiel zu genau einer Artikelgruppe, während eine Gruppe mehrere Artikel enthält. Die Tabelle Artikel erhält daher eine Artikelgruppen-ID als Fremdschlüssel.

So enthält jede Zelle einen atomaren Wert. Mehrere Artikel können über dieselbe Gruppen-ID derselben Artikelgruppe zugeordnet sein.

m:n-Beziehungen abbilden

Für eine m:n-Beziehung legst du eine zusätzliche Zuordnungstabelle an. Sie enthält die Schlüssel der beiden beteiligten Tabellen als Fremdschlüssel. Daraus entstehen zwei 1:n-Beziehungen.

Eine Rechnung kann beispielsweise mehrere Artikel enthalten, und ein Artikel kann auf mehreren Rechnungen vorkommen. Die Zuordnungstabelle erhält deshalb eine Rechnungs-ID sowie eine Artikel-ID. Diese beiden Spalten bilden üblicherweise gemeinsam den Primärschlüssel.

Ich empfehle dir einen fachlich passenden Namen wie Rechnungsposition. In der Prüfung wird auch ein zusammengesetzter Tabellenname wie Artikel_Rechnung akzeptiert.

Attribute an Beziehungen und zusammengesetzte Schlüssel

Wenn eine Beziehung eigene Attribute besitzt, überträgst du diese in die Zuordnungstabelle. Bei einer Rechnungsposition gehören beispielsweise Preis und Menge dazu.

Prüfe dann, ob die beiden Fremdschlüssel gemeinsam jeden Datensatz eindeutig bestimmen. Wenn du wiederholte Käufe eines Artikels durch dieselbe Person abbilden möchtest, reicht die Kombination aus Kunden-ID und Artikel-ID für eine Historie allein nicht aus. Mit einem zusätzlichen Datum im Schlüssel lassen sich Käufe zu unterschiedlichen Zeitpunkten unterscheiden.

Für meine Praxis empfehle ich bei Schlüsseln mit mehr als zwei Spalten eine zusätzliche anonyme ID als Primärschlüssel. Dadurch lassen sich Beziehungen in SQL-Abfragen einfacher formulieren. Bei einem zusammengesetzten Schlüssel müssen die zugehörigen Spalten in einem Join vollständig berücksichtigt werden; ein vergessener Bestandteil kann zu falschen Ergebnissen führen.

In Prüfungsaufgaben empfehle ich dir, zusammengesetzte Schlüssel zu modellieren,...

Eine Kernaufgabe vieler Softwareentwickler - auch in der Abschlussprüfung - ist die Modellierung von Datenbanken. In der achtundvierzigsten Episode des Anwendungsentwickler-Podcasts gehe ich daher die Schritte bei der Modellierung von Datenbanken mit dem Entity-Relationship-Modell durch.

TL;DR

Ich zeige dir, wie du aus einer Aufgabenbeschreibung ein Entity-Relationship-Modell (ERM) entwickelst und seine Kardinalitäten bestimmst. Du erfährst, wie die Chen-Notation funktioniert, wie du Attribute den passenden Entitätstypen oder Beziehungen zuordnest und welche Angaben erst ins relationale Tabellenmodell gehören. An einer Telefonliste für Mitarbeiter:innen gehe ich ein schrittweises Vorgehen durch, mit dem du dein Datenmodell anschließend anhand konkreter Fälle prüfen kannst.

Kapitelmarken

[00:00:20] Datenbankmodelle in Ausbildung und Prüfung

[00:01:39] Das ER-Modell als abstrakte Grundlage

[00:02:49] Chen-Notation und Prüfungsrelevanz

[00:03:57] Entitätstypen, Attribute und Beziehungen zeichnen

[00:06:22] Attribute und Primärschlüssel kennzeichnen

[00:07:05] Entitätstypen und konkrete Entitäten

[00:07:39] Fremdschlüssel und Zuordnungstabellen im Tabellenmodell

[00:09:46] Kardinalitäten in beiden Richtungen bestimmen

[00:11:52] Beispiele für 1:1, 1:n und m:n

[00:14:02] Kardinalitäten im ER-Modell eintragen

[00:15:12] Weitere Beispiele mit Artikeln und Hunden

[00:16:42] Crow’s-Foot-Notation und optionale Beziehungen

[00:20:50] Schrittfolge zum Entwickeln eines ER-Modells

[00:24:46] Attribute an Beziehungen und historische Preise

[00:26:24] Prüfungsbeispiel: Telefonliste für Mitarbeiter:innen

[00:28:19] Begriffe sammeln und Attribute zuordnen

[00:31:52] Attribute ergänzen und Primärschlüssel festlegen

[00:33:46] Beziehungen zwischen Mitarbeiter:in und Anschlusstyp

[00:34:50] Telefonnummer als Beziehungsattribut

[00:37:14] Übrige Begriffe prüfen und das ER-Modell zeichnen

[00:39:17] Das Modell mit konkreten Fällen prüfen

[00:41:14] Die Schrittfolge im Überblick

[00:42:39] Ausblick auf das relationale Tabellenmodell

[00:43:54] Literatur, Projektdokumentation und Java-Anfängerfehler

[00:45:04] Kontakt, Feedback und Newsletter

Inhalt

Modellierung mit dem Entity-Relationship-Modell

Welche Bestandteile hat ein Entity-Relationship-Modell (ERM) und wie sehen sie (in der Chen-Notation) aus?

Entitätstypen (Rechtecke), Attribute (Ovale), Beziehungstypen (Striche mit Rauten) mit Kardinalitäten.

Primärschlüssel werden unterstrichen.

Fremdschlüssel sind nicht (!) enthalten.

m:n-Beziehungen werden nicht (!) aufgelöst.

Vorgehensweise bei der Bestimmung der Kardinalität einer Beziehung: Du musst für die Beziehung zwischen den beiden Entitäten in beide Richtungen separat (!) überlegen, wie viele Ausprägungen der anderen Entität zu einer Ausprägung der aktuellen Entität gehören. Also immer zwei (!) Sätze bilden, die mit "1" beginnen. Dann nimmst du die beiden Ergebnisse der jeweiligen Gegenseite und bist fertig. Beispiele:

Ein Login ist genau einem (1) Benutzer zugeordnet. Ein Benutzer hat genau einen (1) Login. -> 1:1

Ein Artikel gehört zu einer (1) Warengruppe. Eine Warengruppe hat mehrere (n) Artikel. -> 1:n

Ein Hund hat mehrere (m) Herrchen. Ein Herrchen hat mehrere (n) Hunde. -> m:n

Wie funktioniert die crow's foot notation?

Anstatt die Anzahl (0, 1, n, 0..1 usw.) der zugehörigen Datensätze an die Beziehung zu schreiben, wird eine grafische Darstellung verwendet. Die Beziehungslinien werden um 0, 1 oder den Krähenfuß (n) ergänzt.

Wie kommt man zu einem ER-Modell?

Substantive im Aufgabentext (bzw. der Domäne) suchen. Sie sind potentielle Entitätstypen.

Ggfs. konkrete Werte in abstrakte Konzepte übersetzen (z.B. Mercedes in Auto oder gelb in Farbe) und Substantive ergänzen.

Beschreiben die Substantive andere Substantive werden sie zu Attributen. Die beschriebenen Substantive sind dann Entitätstypen.

Ggfs. sinnvolle/notwendige Attribute ergänzen (z.B. Vorname und Nachname bei Personen).

Primärschlüssel kennzeichnen und ggfs. ergänzen.

Beziehungen zwischen Entitätstypen einzeichnen und Kardinalitäten festlegen.

Ggfs. Attribute an die Beziehungen hängen.

Restliche Substantive sinnvoll als Attribute einsortieren oder streichen.

Fertiges Datenmodell mit Beispielen aus der Praxis verifizieren.

Literaturempfehlungen

Einsteigern ins Thema Datenmodellierung empfehle ich die Artikelreihe von Dr. Veikko Krypczyk im Entwickler Magazin. Der erste Artikel ist frei verfügbar: Datenbanken: Grundlagen und Entwurf - entwickler.de.

Das Beispiel (Telefonliste) für den Algorithmus zum Erstellen eines Entity-Relationship-Modells habe ich aus einem der Prüfungstrainer für die Abschlussprüfung*.

*

Ein tolles Buch, um einmal über den Tellerrand der relationalen Datenbanken hinweg zu schauen, ist Seven Databases in Seven Weeks*. Eine relationale Datenbank (PostgreSQL) wird vorgestellt, aber der Rest des Buches behandelt die unterschiedlichsten Typen von (NoSQL-)Datenbanken und ihre Besonderheiten - gerade auch ber der Datenmodellierung. Absolut lesenswert für jeden Softwareentwickler.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Chen-Notation – Wikipedia

Entity-Relationship-Modell – Wikipedia

Martin-Notation – Wikipedia (crow's foot notation)

Letzte Woche im Blog:

Projektdokumentation von Michael Kleimann (mit 92% bewertet) inkl. Projektantrag

Die häufigsten Anfängerfehler bei der Java-Programmierung

Zusammenfassung

Daten mit einem ER-Modell beschreiben

Wenn du als Fachinformatiker:in für Anwendungsentwicklung Software schreibst, brauchst du häufig eine Datenbank. Ich gehe mit dir den Weg von einer Aufgabenbeschreibung zu einem Entity-Relationship-Modell (ERM) durch. Dieses abstrakte Modell beschreibt die Daten einer Domäne und ihre Beziehungen. Es kann als Grundlage für eine relationale Datenbank dienen, ebenso für einen Key-Value-Store oder eine dokumentenorientierte Datenbank.

In der schriftlichen Abschlussprüfung werden häufig ER-Modelle oder Tabellenmodelle verlangt. Auch im Fachgespräch können Prüfer:innen nachfragen, wie du Daten modellierst. Achte deshalb auf die geforderte Darstellungsform und ihre Regeln.

Chen-Notation lesen und zeichnen

Die nach Peter Chen benannte Notation stammt aus den 1970er Jahren. Ihre Zeichen kannst du so einsetzen:

Rechtecke stellen Entitätstypen dar, beispielsweise Mitarbeiter:in.

Ovale enthalten Attribute und sind mit dem jeweiligen Entitätstyp verbunden.

Rauten bezeichnen Beziehungen zwischen Entitätstypen.

Den Primärschlüssel kennzeichnest du, indem du den Namen des Attributs unterstreichst. Bei Mitarbeiter:innen kann das die Personalnummer sein.

Eine Beziehung sollte sich in beide Richtungen lesen lassen. Eine einfache Bezeichnung wie "hat" kann dafür ausreichen: Ein:e Vorgesetzte:r hat Mitarbeiter:innen; ausgehend von einer beschäftigten Person lässt sich die zugehörige Führungskraft bestimmen.

Mit dem Entitätstyp Mitarbeiter:in beschreibst du eine allgemeine Struktur. Eine Entität ist eine konkrete Person, etwa ich als Mitarbeiter. Aus der Objektorientierung kennst du das entsprechende Prinzip von Klasse und Objekt.

Fremdschlüssel und Zuordnungstabellen für m:n-Beziehungen gehören ins relationale Tabellenmodell. Im ER-Modell stellst du die Beziehungen direkt dar. Dadurch bleibt das Modell unabhängig davon, in welcher Datenbank du es später umsetzt.

Kardinalitäten bestimmen

Um eine Beziehung zu beschreiben, gehst du jeweils von einer einzelnen Entität aus und prüfst beide Richtungen getrennt. Entscheidend ist, wie viele zugehörige Entitäten nach den fachlichen Regeln möglich sind. Die erlaubten Möglichkeiten gelten auch dann, wenn gerade erst wenige Datensätze vorhanden sind.

| Kardinalität | Beispiel |

| --- | --- |

| 1:1 | Ein:e Benutzer:in hat genau einen Login, der genau dieser Person gehört. |

| 1:n | Ein:e Vorgesetzte:r kann mehrere Mitarbeiter:innen haben. Jede beschäftigte Person hat im angenommenen hierarchischen Unternehmen genau eine Führungskraft. |

| m:n | Ein:e Lehrer:in kann mehrere Klassen unterrichten. Zu einer Klasse können mehrere Lehrer:innen gehören. |

Bei einer Warengruppe mit mehreren Artikeln ergibt sich ebenfalls eine 1:n-Beziehung, sofern jeder Artikel genau einer Warengruppe zugeordnet ist. Die Aufgabenbeschreibung entscheidet, ob ein Artikel mehreren Gruppen angehören darf. Für m:n lässt sich auch die Beziehung zwischen Hunden und Halter:innen verwenden.

Die Kardinalität schreibst du an das Ende der Beziehungslinie beim gegenüberliegenden Entitätstyp. Wenn eine Führungskraft mehrere Mitarbeiter:innen haben kann, steht das n bei Mitarbeiter:in. Die 1 an der Seite der Führungskraft beschreibt, wie viele Vorgesetzte zu einer beschäftigten Person gehören.

Crow’s-Foot-Notation

Mit der Crow’s-Foot-Notation, auch Martin-Notation genannt, kannst du zusätzlich ausdrücken, ob eine Beziehung optional oder verpflichtend ist:

Ein Kreis steht für null.

Ein Querstrich bezeichnet eins.

Ein Krähenfuß bedeutet mehrere.

Kombinierte Zeichen beschreiben Bereiche wie 0 bis 1, 0 bis n oder 1 bis n. Genau eins lässt sich ebenfalls darstellen.

Die Zeichen stehen am jeweiligen Zielende der Beziehungslinie. Wenn ein Hund mindestens eine:n Halter:in haben muss und mehrere haben darf, stehen bei Halter:in ein Querstrich und ein Krähenfuß.

Für Prüfungen ist vor allem entscheidend, dass deine Darstellung verständlich ist und zur Aufgabe passt. Eine ausdrücklich geforderte Notation hältst du ein. Einheitliche Zeichen helfen anderen Informatiker:innen, dein Modell zu lesen.

Schrittweise von der Aufgabe zum ER-Modell

Ich arbeite beim Entwickeln eines ER-Modells mit folgender Schrittfolge:

Alle Substantive sammeln: Schreibe die Nomen aus dem Aufgabentext zunächst vollständig auf. So behältst du auch Begriffe im Blick, deren Rolle noch unklar ist.

Konkrete Werte verallgemeinern: Aus "gelb" wird beispielsweise Farbe. Namen aus einer Beispieltabelle führen zu den Begriffen Vorname und Nachname.

Attribute zuordnen: Prüfe,...

Eine der häufigsten Fragen im Fachgespräch ist die nach der Zusammensetzung des Stundensatzes, der in fast allen Abschlussprojekten als zentraler Kostenfaktor angeführt wird. In der siebenundvierzigsten Episode des Anwendungsentwickler-Podcasts wird der Stundensatz daher ausführlich besprochen.

TL;DR

In meinem Prüfungsausschuss gehört die Frage nach dem Stundensatz zu den häufigen Themen im Fachgespräch. Für dein Abschlussprojekt berechnest du die Kosten deiner Arbeitszeit aus der Brutto-Ausbildungsvergütung, den Personalnebenkosten und den anteiligen Gemeinkosten; bei einem externen Auftrag kommt je nach Unternehmen ein Gewinnzuschlag dazu. Dazu solltest du erklären können, wie du die verfügbaren Arbeitsstunden ermittelst und Gemeinkosten verteilst, sowie mit Zuschlagskalkulation, Betriebsabrechnungsbogen und den Grundlagen der Preisrechnung vertraut sein.

Kapitelmarken

[00:00:01] Einstieg und Informationen zum Fachgespräch

[00:00:38] Die Frage nach dem Stundensatz

[00:00:59] Projektkosten und Amortisation

[00:02:59] Kosten der Arbeitszeit berechnen

[00:04:45] Bestandteile des Stundensatzes

[00:06:48] Interner und externer Stundensatz

[00:07:37] Rechenbeispiel zur Ausbildungsvergütung

[00:09:08] Personalnebenkosten und freiwillige Leistungen

[00:10:45] Sozialversicherung und Einzugsstellen

[00:12:19] Einzelkosten und Gemeinkosten

[00:16:28] Beispiele für Gemeinkosten

[00:18:12] Zuschlagskalkulation

[00:21:37] Gewinnzuschlag, Skonto und Rabatt

[00:24:37] Handelskalkulation

[00:25:58] Betriebsabrechnungsbogen und Kostenstellen

[00:28:53] Gemeinkosten mit passenden Schlüsseln verteilen

[00:29:52] Gemeinkostenzuschläge im Stundensatz

[00:31:43] Gewinn und kalkulatorischer Unternehmerlohn

[00:33:19] Fixkosten und variable Kosten

[00:34:33] Den Stundensatz im Fachgespräch begründen

[00:35:19] IT-Handbuch und weiterführende Links

[00:35:56] Git-Tipps und Vorstellung des Ausbildungsbetriebs

[00:37:15] Kontakt, Feedback und Checklisten

[00:38:21] Ausblick auf die Datenbankmodellierung

Inhalt

Stundensatz

Wie setzt sich normalerweise (!) ein Stundensatz zusammen?

Bruttogehalt

Personalnebenkosten

Gemeinkosten

Gewinn

Welche Personalnebenkosten gibt es?

Personalnebenkosten aufgrund gesetzlicher und tariflicher Bestimmungen: Arbeitgeberanteil zur Sozialversicherung, Beiträge zur Berufsgenossenschaft, Aufwand nach dem Schwerbehindertengesetz und Mutterschutzgesetz, bezahlte Abwesenheit wie Urlaub, Feiertage, Krankheitstage, Aufwand nach dem Betriebsverfassungsgesetz.

Personalnebenkosten aufgrund freiwilliger Leistungen: Aus- und Fortbildung, Altersversorgung, Werksverpflegung, sonstiger freiwilliger Sozial- und Personalaufwand.

Wer bekommt die Sozialabgaben überwiesen?

Einzugstelle (Krankenkasse); die überweist es weiter an die Sozialversicherungsträger. Unfallversicherung an die Berufsgenossenschaft.

Was sind Gemein- und Einzelkosten?

Einzelkosten können einem Kostenträger direkt zugeordnet werden, Gemeinkosten werden über Zuschlagssätze verteilt.

Was sind übliche Gemeinkosten?

Miete oder Pacht, Steuern und Kapitalkosten (Zinsen), Kosten für die IT, für Telefon, Versicherungen oder für Werbung, Abschreibungen

Wie berechnet man die Gemeinkostenzuschlagsätze?

Mit der Zuschlagskalkulation oder dem Betriebsabrechnungsbogen.

Wird bei einem internen Stundensatz auch Gewinn aufgeschlagen?

Nein, denn über den kalkulatorischen Unternehmerlohn werden die Bezüge der Geschäftsführer bereits erwirtschaftet.

Was sind fixe und variable Kosten?

Fixe Kosten fallen immer an, variable nur wenn produziert wird.

Literaturempfehlungen

Wie schon bei der Erläuterung der Gehaltsabrechnung kann ich wieder nur das IT-Handbuch* (auch "Tabellenbuch" genannt) empfehlen. Es handelt sich beim Stundensatz erneut um ein Wirtschaftsthema, das man auswendig lernen und gut in Tabellen darstellen kann.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Check: Berechnung des Stundenverrechnungssatzes | BMWi-Existenzgründungsportal

Stundensatzkalkulation - Wie einen Stundensatz berechnen?

Definition » Personalnebenkosten « | Gabler Wirtschaftslexikon

Lohnnebenkosten – Wikipedia

Sozialversicherungsträger – Wikipedia

Zuschlagskalkulation – Wikipedia

Betriebsabrechnungsbogen – Wikipedia Weitere Infos zum FachgesprächDu suchst noch mehr Tipps rund um das Fachgespräch? Dann schau doch mal in diese Artikel- und Podcast-Kategorie: Alle Artikel rund um das Fachgespräch.Kennst du schon meine Hörbücher zur Vorbereitung auf das Fachgespräch? Unter dasperfektefachgespraech.de kannst du sie herunterladen. In insg. über 10 Stunden gehe ich über 200 Fragen im Detail durch und gebe Tipps für die Beantwortung.Und wenn du dich für meinen Newsletter einträgst, bekommst du immer direkt alle Neuigkeiten von dieser Seite in dein Postfach geliefert.Jetzt anmelden!

Zusammenfassung

Die Kosten deiner Projektarbeit berechnen

In meinem Prüfungsausschuss wird häufig gefragt, wie sich der Stundensatz im Abschlussprojekt zusammensetzt. Als Fachinformatiker:in brauchst du dafür kaufmännisches Wissen, weil dein Projekt einen wirtschaftlichen Zweck erfüllt. Wenn es beispielsweise Kosten senkt oder höhere Umsätze ermöglicht, kannst du berechnen, wann es die entstandenen Kosten wieder einspielt. Dafür steht der Begriff Amortisation.

Deine Arbeitszeit verursacht Kosten für den Ausbildungsbetrieb. Im Rechenbeispiel dieser Episode umfasst das Projekt 70 Stunden. Über den Stundensatz lässt sich ausrechnen, welchen Betrag du dafür in deiner Projektplanung ansetzt:

Kosten der Projektarbeitszeit = Projektstunden × Stundensatz

Die Ausbildungsvergütung bildet dabei einen Teil der Kosten ab. Dein Betrieb bezahlt außerdem weitere Leistungen und trägt Kosten für das Umfeld, in dem du arbeitest. Im Fachgespräch solltest du die Bestandteile des angesetzten Stundensatzes begründen können.

Welche Bestandteile in den Stundensatz eingehen

Bruttogehalt beziehungsweise Brutto-Ausbildungsvergütung: Dieser Betrag bildet die Grundlage für die Kosten deiner Arbeitszeit.

Personalnebenkosten: Dazu gehören unter anderem die Sozialbeiträge des Arbeitgebers sowie gesetzliche, tarifliche und freiwillige Leistungen.

Gemeinkosten: Kosten, die im Unternehmen für mehrere Leistungen oder Produkte anfallen, werden anteilig eingerechnet.

Gewinnzuschlag: Bei einem Auftrag für Kund:innen wird abhängig vom Unternehmen zusätzlich Gewinn einkalkuliert.

Für ein internes Projekt berechnest du einen internen Stundensatz, der die anfallenden Kosten abdeckt. Ein externer Stundensatz bestimmt, was dein Unternehmen Kund:innen für eine Arbeitsstunde berechnet. Wenn das Unternehmen Gewinn erzielen möchte, fließt dieser in den Preis ein. Gemeinnützige Organisationen können sich auf das Decken ihrer Kosten beschränken.

Die Vergütung auf Arbeitsstunden umrechnen

Für die Rechnung gehst du vom Bruttobetrag aus, den dein Arbeitgeber bezahlt. Als Grundlage eignen sich die tatsächlich verfügbaren Arbeitsstunden eines Jahres. Dabei berücksichtigst du Urlaub und Krankheitstage. Je nach Arbeitsverhältnis kommen Zuschläge hinzu, etwa für Nachtarbeit oder anders vergütete Überstunden.

Den auf eine Stunde entfallenden Bruttobetrag erhältst du, indem du die Vergütung für den betrachteten Zeitraum durch die zugehörigen Arbeitsstunden teilst.

Für mein vereinfachtes Beispiel setze ich 1.000 Euro Ausbildungsvergütung im Monat an. Bei 38,5 Stunden pro Woche und angenommenen vier Arbeitswochen ergeben sich 154 Stunden. Daraus folgen etwa 6,50 Euro pro Stunde. Für 70 Projektstunden sind das gerundet 450 Euro, bevor weitere Kosten eingerechnet werden. Dieses Beispiel vereinfacht die verfügbaren Arbeitsstunden bewusst.

Personalnebenkosten einrechnen

Zusätzlich zur Vergütung fallen für deinen Arbeitgeber unter anderem folgende Kosten an:

Arbeitgeberanteile zur Renten-, Arbeitslosen-, Pflege- und Krankenversicherung;

Beiträge zur Unfallversicherung, die der Arbeitgeber allein trägt;

Aufwendungen aufgrund gesetzlicher Vorgaben, beispielsweise zum Mutterschutz oder nach dem Betriebsverfassungsgesetz;

Kosten im Zusammenhang mit bezahlten Ausfallzeiten, etwa Feiertagen;

freiwillige Leistungen wie Fortbildungen, betriebliche Altersversorgung oder Zuschüsse zur Kantine.

Bei Fortbildungen zählt auch die Zeit, in der ein:e Mitarbeiter:in bezahlt wird und an einer Schulung teilnimmt. Welche Leistungen einfließen, hängt vom jeweiligen Unternehmen ab.

Eine mögliche Anschlussfrage im Fachgespräch betrifft die Stelle, an die der Arbeitgeber die Sozialbeiträge überweist. Die gesetzliche Krankenkasse dient als zentrale Einzugsstelle und verteilt die Beiträge an die zuständigen Sozialversicherungsträger weiter. Beiträge zur Unfallversicherung gehen üblicherweise an die Berufsgenossenschaft.

Einzelkosten und Gemeinkosten zuordnen

Einzelkosten lassen sich einem Kostenträger direkt zuordnen, beispielsweise einem bestimmten Produkt. Bei einem Stahlträger kann das die Menge an Eisenerz sein, die für ihn gebraucht wird. Auch Arbeitskosten können direkt zugeordnet werden, etwa wenn ein:e Mitarbeiter:in nach Stückzahl oder Stunden bezahlt wird. Bei einem festen Gehalt ist diese Zuordnung schwieriger.

Gemeinkosten werden über passende Schlüssel oder Zuschläge verteilt. Dazu zählen beispielsweise:

Miete oder Pacht für Gebäude;

Energie sowie Telefonkosten;

Steuern und Zinsen;

Abschreibungen auf Anlagegüter, etwa Maschinen oder Firmenwagen;

Kosten für interne Abteilungen wie Personal, Rechnungswesen oder IT;

Versicherungen und Werbung.

Wenn eine Halle monatlich 1.000 Euro Miete kostet und darin zehn Stahlträger gefertigt werden, lassen sich in einem einfachen Beispiel jedem Stahlträger 100 Euro Miete zurechnen.

Mit der Zuschlagskalkulation rechnen

Bei der Zuschlagskalkulation gehst du schrittweise entlang des Ablaufs im Unternehmen vor:

Du beginnst mit den Materialeinzelkosten, beispielsweise für Eisenerz.

Materialgemeinkosten kommen hinzu, etwa die Miete für ein Materiallager.

...

Der Wirtschaftsteil der Ausbildung wird von vielen Prüflingen unterschätzt. Es wird Zeit, die häufigsten Wirtschaftsfragen im Fachgespräch zu besprechen. Die sechsundvierzigste Episode des Anwendungsentwickler-Podcasts behandelt die Gehaltsabrechnung.

TL;DR

Für dein Fachgespräch als Fachinformatiker:in Anwendungsentwicklung empfehle ich dir, auch Wirtschaftsfragen vorzubereiten: Du solltest deine Gehaltsabrechnung vom Bruttoentgelt bis zum ausgezahlten Betrag erklären können. Dazu gehören die Steuern und die fünf Sozialversicherungen mit ihren Beitragssätzen sowie den Anteilen, die Arbeitgeber:in und Arbeitnehmer:in tragen. Wenn du zunächst einen Überblick gibst und anschließend die einzelnen Posten vertiefst, bekommt deine Antwort einen nachvollziehbaren Aufbau. Die genannten Zahlen beziehen sich auf 2016.

Kapitelmarken

[00:00:01] Einstieg ins Fachgespräch

[00:00:43] Wirtschaftsfragen in der IT-Abschlussprüfung

[00:01:49] Gehaltsabrechnung als Grundlage für den Stundensatz

[00:02:58] Antworten im Fachgespräch strukturiert aufbauen

[00:05:06] Brutto und Netto

[00:06:40] Lohn und Gehalt

[00:07:59] Ausbildungsvergütung für IT-Azubis

[00:08:26] Beitragsbemessungsgrenze

[00:10:04] Versicherungspflichtgrenze und Krankenversicherungspflicht

[00:12:26] Gesetzliche und private Krankenversicherung

[00:15:33] Gehaltsabrechnung und IT-Handbuch

[00:16:44] Vom Bruttoentgelt zum ausgezahlten Betrag

[00:18:03] Vermögenswirksame Leistungen

[00:19:02] Welche Details im Fachgespräch gefragt werden

[00:20:22] Lohnsteuer und Steuerklassen

[00:22:09] Solidaritätszuschlag und Kirchensteuer

[00:23:17] Rentenversicherung und Arbeitgeberanteile

[00:24:49] Krankenversicherung und Zusatzbeitrag

[00:25:20] Arbeitslosenversicherung

[00:25:36] Pflegeversicherung und Kinderlosenzuschlag

[00:26:43] Gesetzliche Unfallversicherung

[00:27:50] Wirtschaftsfragen für die Prüfung vorbereiten

[00:29:19] Ausblick auf Stundensatz und Projektkosten

[00:29:58] Literatur und aktuelle Beitragssätze

[00:31:03] Zeitrahmen der Abschlusspräsentation

[00:31:24] Oath of the Programmer und Pfadfinderregel

[00:32:37] Links empfehlen und Feedback geben

[00:33:27] Newsletter und Checkliste zur Projektarbeit

Inhalt

Allgemeines

Was ist der Unterschied zwischen Netto und Brutto?

Netto ist ein Teil des Brutto.

Was ist der Unterschied zwischen Lohn und Gehalt?

Gehalt ist unabhängig von der erbrachten Leistung und somit jeden Monat gleich hoch.

Welches Arbeitsentgelt erhält ein Azubi?

Ausbildungsvergütung.

Was ist die Beitragsbemessungsgrenze?

Der Teil des Einkommens, der die Beitragsbemessungsgrenze (2016: 74.400 EUR) übersteigt, bleibt für die Beitragsberechnung der Sozialversicherung außer Betracht.

Was ist die Versicherungspflichtgrenze?

Die Versicherungspflichtgrenze (auch Jahresarbeitsentgeltgrenze) bestimmt, ab welcher Höhe des jährlichen Arbeitsentgelts (2016: 56.250 EUR) ein Arbeitnehmer nicht mehr in der gesetzlichen Krankenversicherung pflichtversichert sein muss.

Achtung: Es gibt eine Pflicht zur Krankenversicherung!

Gehaltsabrechnung

Wie ist die Gehaltsabrechnung grundsätzlich aufgebaut?

Bruttoentgelt

(+) ggfs. vermögenswirksame Leistungen

= steuerpflichtiges Bruttoentgelt

(-) Steuern

(-) Sozialversicherung

= Nettoentgelt

(-) ggfs. vermögenswirksame Sparleistungen

= Auszahlungsbetrag

Welche Sozialversicherungen gibt es?

Rentenversicherung (2016: 18,7%), 50%/50% AG/AN

Krankenversicherung (2016: 14,6%), 50%/50% AG/AN + Zusatzbeitrag für AN

Arbeitslosenversicherung (2016: 3%), 50%/50% AG/AN

Pflegeversicherung (2016: 2,35%), 50%/50% AG/AN + 0,25% für kinderlose AN ab 23 Jahren

Unfallversicherung, 100% AG

Welche Steuern gibt es?

Lohnsteuer, abhängig von Steuerklasse, Einkommenshöhe und Steuersatz

Solidaritätszuschlag, 5,5% der Lohnsteuer

Kirchensteuer, 9% bzw. 8% der Lohnsteuer

Literaturempfehlungen

Zu den Wirtschaftsfragen kann ich eigentlich nur das IT-Handbuch* (auch "Tabellenbuch" genannt) empfehlen. Es handelt sich ja um Themen, die man gut in Tabellen darstellen und recht einfach auswendig lernen kann. Das IT-Handbuch enthält auch einige Links auf "offizielle" Quellen für die aktuellen Beitragssätze usw.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Netto – Wikipedia

Arbeitsentgelt – Wikipedia

Ausbildungsvergütung – Wikipedia

Beitragsbemessungsgrenze – Wikipedia

Versicherungspflichtgrenze – Wikipedia Weitere Infos zum FachgesprächDu suchst noch mehr Tipps rund um das Fachgespräch? Dann schau doch mal in diese Artikel- und Podcast-Kategorie: Alle Artikel rund um das Fachgespräch.Kennst du schon meine Hörbücher zur Vorbereitung auf das Fachgespräch? Unter dasperfektefachgespraech.de kannst du sie herunterladen. In insg. über 10 Stunden gehe ich über 200 Fragen im Detail durch und gebe Tipps für die Beantwortung.Und wenn du dich für meinen Newsletter einträgst, bekommst du immer direkt alle Neuigkeiten von dieser Seite in dein Postfach geliefert.Jetzt anmelden!

Zusammenfassung

Im Fachgespräch strukturiert antworten

Als Fachinformatiker:in Anwendungsentwicklung brauchst du auch kaufmännisches Wissen, das in der schriftlichen Prüfung und im Fachgespräch gefragt wird. Die eigene Gehaltsabrechnung zu erläutern gehört zu den häufigen Wirtschaftsfragen. Das Gehalt spielt außerdem eine große Rolle, wenn du einen Stundensatz für deine Projektarbeit berechnest.

Für deine Antwort empfehle ich dir, zunächst einen Überblick über die Abrechnung zu geben. Danach kannst du die einzelnen Posten vertiefen, indem du etwa der Reihenfolge auf deiner Abrechnung folgst. So behältst du im Kopf, welche Punkte du ansprechen möchtest, und gibst deiner Antwort einen logischen Aufbau.

Begriffe rund um dein Entgelt

Bruttoentgelt bezeichnet das vereinbarte Entgelt, von dem unter anderem Steuern und Sozialabgaben abgezogen werden.

Nettoentgelt bleibt übrig, nachdem diese Abzüge erfolgt sind. Weitere Posten, etwa Geld für einen vermögenswirksamen Sparvertrag, können den Betrag verändern, der auf deinem Konto ankommt.

Gehalt wird als fester Betrag regelmäßig gezahlt, beispielsweise monatlich. Es ist unabhängig davon, wie viel Leistung du im jeweiligen Monat erbracht hast.

Lohn richtet sich nach einer erbrachten Leistung, etwa nach Arbeitsstunden oder der Zahl montierter Teile. Historisch werden Menschen mit Lohn als Arbeiter:innen und Menschen mit Gehalt als Angestellte bezeichnet.

Als IT-Azubi erhältst du eine Ausbildungsvergütung, die während deiner Ausbildung zum Lebensunterhalt beiträgt.

Dein:e Arbeitgeber:in trägt zusätzlich zum vereinbarten Bruttoentgelt eigene Anteile an den Sozialversicherungen. Diese Kosten gehören dazu, wenn später ein Stundensatz berechnet wird.

Grenzen für die Sozialversicherung

Die Beitragsbemessungsgrenze legt fest, bis zu welchem Einkommen Sozialversicherungsbeiträge berechnet werden. Der Anteil des Einkommens oberhalb dieser Grenze bleibt bei der Beitragsberechnung außen vor. Dadurch ergibt sich ein Höchstbeitrag. Als Beispiel für die Rentenversicherung werden für 2016 eine Grenze von 74.400 Euro jährlich und ein Beitragssatz von 18,7 Prozent genannt.

Mit der Versicherungspflichtgrenze, auch Jahresarbeitsentgeltgrenze genannt, hängt zusammen, wann du als Arbeitnehmer:in in eine private Krankenversicherung wechseln kannst. Für 2016 beträgt der genannte Wert 56.250 Euro jährlich. Wenn dein Einkommen darüber liegt, kannst du dich privat krankenversichern oder weiterhin in der gesetzlichen Krankenversicherung bleiben. Die Pflicht, krankenversichert zu sein, besteht weiterhin.

Selbstständige können ihre Krankenversicherung unabhängig von dieser Einkommensgrenze wählen. Für Beamt:innen spielt die staatliche Beihilfe eine Rolle, die einen Teil ihrer Krankheitskosten übernimmt.

Krankenversicherung: Beiträge und Leistungen

In der gesetzlichen Krankenversicherung wird der Beitrag anhand des Einkommens berechnet. Die beitragsfreie Familienversicherung ermöglicht es insbesondere, Kinder mitzuversichern. Für zusätzliche Leistungen lassen sich ergänzende Versicherungen abschließen, beispielsweise für ein Einbettzimmer im Krankenhaus.

Bei einer privaten Krankenversicherung wird jede Person einzeln versichert und zahlt einen eigenen Beitrag. Für dessen Höhe spielt das individuelle Risiko eine Rolle, beispielsweise das Alter beim Eintritt. Es gelten Unisex-Tarife. Steigende Krankheitskosten können dazu führen, dass ein:e Versicherer:in die Beiträge für den versicherten Bestand anpasst.

Vom Bruttoentgelt zum ausgezahlten Betrag

Das vorgestellte Schema lässt sich Schritt für Schritt durchgehen:

Ausgangspunkt ist das Bruttoentgelt aus deinem Arbeitsvertrag.

Falls dein:e Arbeitgeber:in vermögenswirksame Leistungen zahlt, werden diese hinzugerechnet. Daraus ergibt sich im dargestellten Schema das steuerpflichtige Bruttoentgelt.

Die Steuern werden abgezogen.

Anschließend werden deine Sozialversicherungsbeiträge abgezogen. Übrig bleibt das Nettoentgelt.

Fließt Geld in einen vermögenswirksamen Sparvertrag, wird dieser Betrag vom Nettoentgelt abgezogen. Danach steht fest, wie viel du ausgezahlt bekommst.

Ob dein Betrieb vermögenswirksame Leistungen zahlt, kann beispielsweise durch einen Tarifvertrag oder eine individuelle Vereinbarung geregelt sein. Das Geld soll dir helfen, langfristig Vermögen aufzubauen, etwa über einen Bausparvertrag oder einen Banksparvertrag. Als üblicher Betrag werden 40 Euro monatlich genannt. Die Leistung wird beim Brutto berücksichtigt und versteuert; der Sparbetrag wird anschließend aus dem Netto an den jeweiligen Vertrag überwiesen.

Steuern auf der Gehaltsabrechnung

Die folgenden Zahlen beziehen sich auf 2016.

| Posten | Grundlage und genannte Höhe |

| --- | --- |

| Lohnsteuer | Hängt vom Einkommen und der Steuerklasse ab; die Höhe richtet sich nach dem jeweiligen Steuersatz. |

| Solidaritätszuschlag | 5,5 Prozent der Lohnsteuer. |

| Kirchensteuer | Bei entsprechender Kirchenmitgliedschaft je nach Bundesland 8 oder 9 Prozent der Lohnsteuer. |

...

Getter und Setter, ein vernünftiges Klassendesign und Enumerations sind die Themen der fünfundvierzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Mit meiner Lernzielkontrolle vertiefst du als IT-Azubi die Grundlagen der Objektorientierung. Über Getter und Setter steuerst du, wie auf Attribute zugegriffen wird, wobei du Werte berechnen oder vor dem Setzen prüfen kannst. Beim Klassendesign helfen dir klar abgegrenzte Aufgaben und sprechende Namen; außerdem sollten Methoden und Attribute eng zusammengehören und Abhängigkeiten gering bleiben. Enumerations legen erlaubte Werte als eigenen Datentyp fest, sodass dich der Compiler vor ungültigen Angaben schützt.

Kapitelmarken

[00:00:20] Themen der Lernzielkontrolle

[00:01:12] Getter und Setter als Zugriffsmethoden

[00:02:54] Lesezugriff und Schreibzugriff steuern

[00:03:54] Unveränderbare Objekte und Java-Strings

[00:05:16] Werte im Getter berechnen

[00:06:05] Werte im Setter prüfen

[00:07:19] Getter und Setter in deutschsprachigem Code benennen

[00:08:41] Klassendesign und Single Responsibility Principle

[00:10:40] Klassen wiederverwenden und Abhängigkeiten begrenzen

[00:12:25] Sprechende Klassennamen und Codevervollständigung

[00:15:19] Attribute zunächst privat halten

[00:15:41] Geringe Kopplung

[00:17:26] Hohe Kohärenz und Klassen aufteilen

[00:21:20] Enumerations für festgelegte Werte

[00:24:10] Aufzählungstypen und Typsicherheit

[00:26:19] Eigene Methoden in Java-Enums

[00:27:42] Unterstützung durch Compiler und IDE

[00:28:19] Ausblick auf Wirtschaftsfragen im Fachgespräch

[00:29:01] Shownotes und Literaturempfehlungen

[00:30:30] Handouts und Tipps für Präsentationen

[00:31:50] Kontakt und Newsletter

Inhalt

Getter und Setter

Wie steuert man den Zugriff auf Instanzvariablen?

Über dafür vorgesehene Methoden: Getter und Setter.

Was sind Getter und Setter?

Methoden zum Setzen und Lesen von Instanzvariablen.

Welchen Vorteil haben Setter im Vergleich zu public Attributen?

Man kann z.B. das Setzen ungültiger Werte verhindern.

Welchen Vorteil haben Getter im Vergleich zu public Attributen?

Man kann z.B. zusätzliche Berechnungen ausführen.

Klassendesign

Was sind die grundlegenden Regeln beim Schreiben von Klassen?

Eine Klasse sollte nur eine einzige Aufgabe haben (Single Responsibility Principle).

Sie sollte einen sprechenden Namen haben.

Sie sollte keine Attribute public machen (Geheimnisprinzip).

Sie sollte eine hohe Kohärenz aufweisen.

Sie sollte eine geringe Kopplung aufweisen.

Enumerations

Was ist eine Enumeration?

Ein Datentyp, der eine abgeschlossene Liste an Werten definiert.

Wann und warum sollte man Enumerations verwenden (und nicht Strings oder Integers)?

Wenn die Anzahl der erlaubten Werte begrenzt ist bekommt man durch eine Enumeration eine Art "Typsicherheit".

Literaturempfehlungen

*(direkt beim Rheinwerk-Verlag bestellen*)

*(direkt beim Rheinwerk-Verlag bestellen*)

Viele weitere "Regeln" zum Schreiben von Klassen (oder auch grundsätzlich zur sauberen Programmierung) findest du in Clean Code*.

*

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

ArticleS.UncleBob.PrinciplesOfOod

The Single Responsibility Principle (PDF)

Robert C. Martin - The Single Responsibility Principle. on Vimeo

Strive for low coupling and high cohesion What does that even mean

Zusammenfassung

Getter und Setter

Wenn du Attribute als private deklarierst, bleiben die inneren Werte deiner Klasse nach außen verborgen. Über Methoden kannst du gezielt festlegen, wie andere Klassen darauf zugreifen dürfen. Ein Getter liest einen Wert, während ein Setter einen Wert setzt.

Dabei lässt sich der Zugriff für jede Richtung einzeln festlegen:

Mit einem öffentlichen Getter gibst du einen Wert zum Lesen frei. Welche Methoden ihn verändern dürfen, bestimmst du separat.

Ein Setter mit protected erlaubt abgeleiteten Klassen, den Wert zu setzen.

Über einen privaten Setter kann die Klasse selbst ihre Werte verändern.

Unveränderbare Objekte

Wenn mehrere Threads gleichzeitig denselben Wert verändern, können Probleme entstehen. Bei unveränderbaren Objekten, auf Englisch immutable objects, bleibt der Zustand nach dem Erzeugen erhalten.

In Java ist String ein Beispiel dafür. Bei einem Ausdruck wie text += "abc" entsteht ein neuer String mit dem ergänzten Inhalt. Der ursprüngliche String behält seinen Wert. Mit privaten Attributen und Gettern kannst du den Zugriff von außen auf das Lesen beschränken.

Logik in Zugriffsmethoden

Bei einer Klasse Person kann getAlter() das Alter aus dem gespeicherten Geburtsdatum und dem heutigen Datum berechnen. Dadurch brauchst du keinen zusätzlichen gespeicherten Alterswert.

Bevor ein Setter einen neuen Wert übernimmt, kann er prüfen, ob dieser gültig ist. Für ein Alter könnte beispielsweise der Bereich von 0 bis 200 gelten. Bei einem Wert außerhalb dieses Bereichs lässt sich eine Exception auslösen oder das Setzen ablehnen. Als Entwickler:in sorgst du dafür, dass dein Objekt in einem gültigen Zustand bleibt.

Namen für Getter und Setter

In meiner Praxis programmiere ich versicherungsinterne Software häufig auf Deutsch, weil sich Fachbegriffe so verständlich im Code ausdrücken lassen. Auch dabei behalte ich die Präfixe get und set bei, etwa in getKilometerstand(). Daran erkennst du die Rolle der Methode direkt. Eine passende deutsche Variante für get habe ich für mich bisher nicht gefunden.

Klassen entwerfen

Eine klar abgegrenzte Aufgabe

Beim Schreiben einer Klasse orientiere ich mich am Single Responsibility Principle. Die ursprüngliche Regel lautet: Eine Klasse sollte genau einen Grund haben, geändert zu werden. Häufig wird das als eine einzige Aufgabe oder Verantwortung beschrieben.

Wenn ein Dateimanager sowohl Dateien liest als auch schreibt, kann eine Änderung beim Schreiben versehentlich das Lesen beeinträchtigen. Durch getrennte Klassen bleiben die Aufgaben überschaubar. Du kannst eine solche Klasse außerdem leichter in einem anderen Programm einsetzen, weil sie nur die Abhängigkeiten ihrer eigenen Aufgabe mitbringt.

Gerade bei zusätzlichen Frameworks kann eine breit angelegte Klasse aufwendig werden: Für eine einzelne benötigte Funktion musst du dann möglicherweise weitere Bibliotheken einbinden und konfigurieren.

Sprechende Namen und private Attribute

Mit Namen wie Dateileser oder Dateischreiber wird die Aufgabe einer Klasse direkt erkennbar. Bezeichnungen wie Manager oder Utility lassen offen, was die Klasse genau macht.

Für eine spezielle Aufgabe darf der Name länger ausfallen. Aus meiner Praxis stammt etwa ein "blocksammelnder Datensatzschreiber". Beim Eingeben hilft dir die IDE: In Eclipse kannst du die Anfangsbuchstaben der einzelnen Wörter eingeben und den Namen mit Strg + Leertaste vervollständigen lassen.

Als Ausgangspunkt setze ich alle Attribute auf private. Anschließend entscheide ich einzeln, welche Werte über Zugriffsmethoden nach außen zugänglich werden.

Geringe Kopplung

Wenn deine Klasse andere Klassen oder Bibliotheken benötigt, bestehen Abhängigkeiten. Der Begriff Kopplung beschreibt diese Beziehungen. Mit jeder weiteren Abhängigkeit wird es aufwendiger, die Klasse an anderer Stelle einzusetzen; auch die Fehlersuche kann schwieriger werden. Eingebundene Bibliotheken können ihrerseits weitere Bibliotheken benötigen.

Da Klassen in einem objektorientierten System zusammenarbeiten, gehören Abhängigkeiten zum Alltag. Halte sie möglichst gering, damit sich deine Klassen leichter wiederverwenden lassen.

Hohe Kohärenz

Wie eng Methoden und Attribute einer Klasse zusammenarbeiten, beschreibe ich hier als Kohärenz. Eine hohe Kohärenz liegt vor, wenn die Methoden die Attribute der Klasse umfassend verwenden.

Bei einer Klasse Auto verändert die Methode zum Fahren beispielsweise den Kilometerstand. Eine Methode zum Öffnen der Türen arbeitet mit den Türobjekten. Dass diese Methoden jeweils unterschiedliche Attribute ansprechen, passt zum abgebildeten Konzept.

Wenn bei einer großen Klasse einzelne Gruppen von Methoden jeweils nur wenige Attribute bearbeiten, kann das auf mehrere Aufgaben hinweisen. Dann lohnt es sich zu prüfen, ob du diese Gruppen in eigene, kleinere Klassen aufteilen kannst. So hängt die Kohärenz mit dem Single Responsibility Principle zusammen.

Enumerations

Wenn ein Attribut nur Werte aus einer festgelegten Liste annehmen darf, kannst du dafür eine Enumeration, kurz enum, anlegen. Dieser Aufzählungstyp definiert die erlaubten Werte als Konstanten.

Für Wochentage lässt sich beispielsweise ein Typ Wochentag mit sieben Konstanten festlegen. Im Code greifst du dann auf einen Wert wie Wochentag.MONTAG zu. Auch das Lieblingsessen eines Hundes kann als Enumeration abgebildet werden, wenn deine Anwendung dafür eine feste Auswahl vorgibt.

Typsicher arbeiten

Bei einem frei eingegebenen String können Tippfehler auftreten. Ein Integer erlaubt Werte außerhalb des vorgesehenen Bereichs und verrät außerdem wenig darüber, welche Zahl welchen Wochentag bezeichnet.

Mit einem Enum-Typ in der Methodensignatur wird sichtbar, welche Werte erwartet werden. Der Java-Compiler prüft den Typ und weist unzulässige Angaben zurück. Deine IDE kann dir die definierten Konstanten beim Schreiben des Codes vorschlagen.

Methoden in Java-Enums

Java-Enumerations besitzen Eigenschaften von Klassen und können eigene Methoden enthalten. Wenn du aus einem Formular einen String erhältst, kannst du beispielsweise direkt im Enum eine Methode bereitstellen, die daraus den passenden Enum-Wert ermittelt.

Literatur und weitere Inhalte

Unter anwendungsentwicklerpodcast.de/45 findest du meine Shownotes mit weiterführenden Links zum Single Responsibility Principle sowie zu Kohärenz und Kopplung.

Als Literatur empfehle ich dir die Einführung in Java beziehungsweise die Java-Insel aus dem Rheinwerk-Verlag. Für das Klassendesign kommt Clean Code von Bob Martin hinzu, das praxisnahe Tipps auch für Programmieranfänger:innen enthält.

Auf meiner Website verweise ich außerdem auf meinen Artikel zu Handouts bei der Projektpräse

Sichtbarkeitsmodifizierer und Konstruktoren sind die Themen der vierundvierzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

An der Klasse Auto zeige ich dir, wie du mit this auf das aktuelle Objekt zugreifst und Konstruktoren miteinander verknüpfst. Konstruktoren sorgen dafür, dass ein neues Objekt gültige Attributwerte erhält, während Sichtbarkeitsmodifizierer den Zugriff auf seine Attribute und Methoden regeln. Als Entwickler:in deiner Klasse bist du dafür verantwortlich, dass sie sich vollständig initialisiert und andere Entwickler:innen direkt mit ihren Objekten arbeiten können.

Kapitelmarken

[00:00:01] Einstieg in die zweite Lernzielkontrolle zur Objektorientierung

[00:01:53] this als Referenz auf das aktuelle Objekt

[00:05:23] Konstruktoren und gültige Objektzustände

[00:08:08] Konstruktoren definieren und überladen

[00:10:13] Gemeinsamen Konstruktorcode mit this wiederverwenden

[00:14:25] Faustregel für verkettete Konstruktoren

[00:15:05] Kapselung und Geheimnisprinzip

[00:16:45] Sichtbarkeit mit public, private und protected regeln

[00:20:24] Package-private in Java

[00:22:06] Empfehlungen zur Sichtbarkeit und zu Tests

[00:23:45] Die Java-Sichtbarkeiten im Überblick

[00:24:47] Instanzvariablen vollständig initialisieren

[00:27:23] Anfangswerte im Code setzen

[00:29:37] Namenskonflikte mit this auflösen

[00:32:12] Ausblick, Literatur und weiterführende Links

Inhalt

Konstruktoren

Was macht das Schlüsselwort this?

Referenz auf das aktuelle Objekt.

Was ist die Aufgabe eines Konstruktors?

Ein Objekt zu erzeugen und es in einen gültigen Zustand zu versetzen.

Wie definiert man einen Konstruktor?

In Java: Methode ohne Rückgabewert und dem gleichen Namen wie die Klasse.

Was ist ein Default-Konstruktor?

Der parameterlose Konstruktor einer Klasse, der ggfs. durch Java selbst erzeugt wird.

Sichtbarkeitsmodifizierer

Wie steuert man die Sichtbarkeit von Attributen und Methoden von Klassen?

Mit den Sichtbarkeitsmodifizierern private, protected, public und package-private.

Was ist die standardmäßige Sichtbarkeit in Java?

package-private

Wie kann man Instanzvariablen initialisieren?

Inline bei ihrer Deklaration, im Konstruktor oder in einer Methode.

Muss man Instanzvariablen immer über this ansprechen?

Nein, nur wenn es einen Namenskonflikt gibt.

Literaturempfehlungen

*(direkt beim Rheinwerk-Verlag bestellen*)

*(direkt beim Rheinwerk-Verlag bestellen*)

Links

Permalink zu dieser Podcast-Episode

RSS-Feed des Podcasts

Controlling Access to Members of a Class (The Java™ Tutorials > Learning the Java Language > Classes and Objects)

Rheinwerk Computing :: Java ist auch eine Insel - 5.2 Privatsphäre und Sichtbarkeit

Rheinwerk Computing :: Java ist auch eine Insel - 5.5 Objekte anlegen und zerstören

Zusammenfassung

Mit this auf das aktuelle Objekt zugreifen

Wenn du mit Auto a = new Auto(); ein Objekt erzeugst, kannst du über die Referenz a seine zugänglichen Methoden aufrufen. Innerhalb des Objekts steht dir dafür this als Referenz auf das aktuelle Objekt zur Verfügung. Mit this.kilometerstand += 1; erhöhst du beispielsweise den eigenen Kilometerstand.

In einer Methode der Klasse Auto bezieht sich this auf das jeweilige Autoobjekt. Schreibst du es innerhalb einer Methode der Klasse Autowaschanlage, verweist es auf das aktuelle Objekt dieser Klasse.

Für eine Prüfung kannst du dir die Formulierung merken: this ist eine Referenz auf das aktuelle Objekt.

Konstruktoren und gültige Objektzustände

Beim Erzeugen eines Objekts wird ein Konstruktor aufgerufen, der dessen Attribute mit gültigen Werten versieht. Der Zustand eines Objekts ergibt sich aus den aktuellen Werten aller seiner Attribute.

Java gibt Instanzvariablen zunächst Standardwerte. Numerische Attribute erhalten 0, bei einem booleschen Attribut ist der Wert false. Referenzen wie String-Attribute beginnen mit null. Welche Werte fachlich gültig sind, hängt von deiner Klasse ab. Ein leerer String kann beispielsweise verhindern, dass der spätere Zugriff auf dieses Attribut einen Null-Pointer-Fehler auslöst.

Wenn du in Java keinen eigenen Konstruktor definierst, erzeugt die Sprache einen parameterlosen Default-Konstruktor. Sobald deine Klasse eigene Schritte braucht, um einen gültigen Zustand herzustellen, musst du diese selbst programmieren.

So sieht ein Konstruktor aus

In Java und C# trägt ein Konstruktor exakt den Namen seiner Klasse, einschließlich der Groß- und Kleinschreibung. Der Rückgabetyp entfällt vollständig, auch void.

Für die Klasse Auto lautet ein parameterloser Konstruktor beispielsweise:

java

Auto() {

this.kilometerstand = 0;

}

Du kannst Konstruktoren überladen, indem du unterschiedliche Parameterlisten definierst. Für einen Gebrauchtwagen lässt sich der vorhandene Kilometerstand direkt beim Erzeugen übergeben:

java

Auto(int kilometerstand) {

this.kilometerstand = kilometerstand;

}

Konstruktoren miteinander verknüpfen

Wenn mehrere Konstruktoren dieselben Attribute setzen, kannst du den gemeinsamen Code an einer Stelle halten. In Java ruft ein Konstruktor mit this(...) einen anderen Konstruktor derselben Klasse auf:

java

Auto() {

this(0);

}

Auto(int kilometerstand) {

this.kilometerstand = kilometerstand;

}

Beim Aufruf von new Auto() wird dadurch der Konstruktor mit dem Kilometerstand 0 ausgeführt. Ändert sich die gemeinsame Logik, bearbeitest du nur eine Stelle.

Als Faustregel empfehle ich dir, einen Konstruktor mit weniger Parametern den Konstruktor mit mehr Parametern aufrufen zu lassen. Dabei übergibt er die passenden Standardwerte.

Kapselung und Geheimnisprinzip

Eine Klasse fasst ihre Attribute mit den zugehörigen Methoden zu einer Einheit zusammen. Das bezeichnet Kapselung. Beim Geheimnisprinzip hält die Klasse ihre internen Werte verborgen und kontrolliert, wie andere Klassen darauf zugreifen dürfen.

Am Kilometerstand lässt sich der Zweck erkennen: Ein direkter Zugriff von außen könnte einen negativen Wert erlauben oder dazu führen, dass jemand den Kilometerstand eines Gebrauchtwagens zurücksetzt. Über Sichtbarkeitsmodifizierer legst du fest, welche Klassen auf Attribute und Methoden zugreifen dürfen.

Sichtbarkeit in Java

| Sichtbarkeit | Zugriff möglich für |

| --- | --- |

| private | Die definierende Klasse selbst |

| package-private | Die Klasse selbst und alle Klassen im selben Package |

| protected | Die Klasse selbst, Klassen im selben Package sowie Subklassen außerhalb des Packages |

| public | Alle Klassen |

Package-private entsteht, wenn du den Sichtbarkeitsmodifizierer weglässt. Dafür gibt es in Java ein eigenes Verhalten, aber kein Schlüsselwort. Ober- und Unterpackages zählen jeweils als andere Packages.

Bei Vererbung kann beispielsweise die Klasse Cabrio von Auto abgeleitet sein. Mit protected erhalten Subklassen Zugriff auf die entsprechend geschützten Member.

Für deinen Einstieg empfehle ich dir, Attribute und Methoden zunächst auf private zu setzen. Anschließend erweiterst du den Zugriff gezielt dort, wo deine Klasse ihn braucht.

Package-private kann zusammengehörigen Klassen innerhalb eines Packages Zugriff auf interne Member geben, etwa in einem Framework. Auch Testklassen im selben Package können so auf entsprechend zugängliche Methoden zugreifen. Ich habe dafür in meiner Praxis bislang keinen Bedarf gehabt und empfehle, private Methoden nicht direkt zu testen.

Instanzvariablen vollständig initialisieren

Wenn du eine Klasse programmierst, kennst du ihre internen Abläufe und die Bedingungen für gültige Werte. Dieses Wissen gehört in die Klasse. Andere Entwickler:innen sollen mit einem neu erzeugten Objekt arbeiten können, ohne erst eine bestimmte Folge von Setter-Aufrufen kennen zu müssen.

Java und C# erzwingen eine solche Folge späterer Methodenaufrufe nicht. Deshalb muss deine Klasse selbst dafür sorgen, dass notwendige Schritte in der richtigen Reihenfolge stattfinden, einschließlich erforderlicher Berechnungen oder Datenbankzugriffe.

Du kannst einen festen Anfangswert direkt bei der Deklaration setzen:

java

private int kilometerstand = 0;

Im Konstruktor lässt sich der Wert ebenfalls zuweisen, beispielsweise anhand eines übergebenen Parameters. Für komplexere Berechnungen kannst du eine eigene Methode schreiben, die das Attribut setzt. Der Konstruktor muss diese Methode dann aufrufen, damit das Objekt anschließend einen gültigen Zustand hat.

Wann du this beim Zugriff brauchst

Bei einem eindeutigen Attributnamen kannst du innerhalb der Klasse direkt kilometerstand = 0; schreiben. Hat ein Parameter oder eine lokale Variable denselben Namen, wird dieser Name im näheren Gültigkeitsbereich verwendet.

Im folgenden Konstruktor bezeichnet kilometerstand den Parameter. Über this.kilometerstand sprichst du ausdrücklich das Attribut des aktuellen Objekts an:

java

Auto(int kilometerstand) {

this.kilometerstand = kilometerstand;

}

Du kannst den Parameter auch neuerKilometerstand nennen. Dann ist mit kilometerstand = neuerKilometerstand; eindeutig, welcher Wert welchem Attribut zugewiesen wird.

Weiterführendes Material

Unter anwendungsentwicklerpodcast.de/44 habe ich einen Oracle-Tutorialartikel mit einer Matrix zu den Sichtbarkeiten verlinkt. Dort findest du auch die Literaturempfehlungen "Einführung in Java" und "Java ist auch eine Insel". Getter und Setter sowie das Single Responsibility Principle sind für eine folgende Folge vorgesehen.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:01] Herzlich willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker

[0:08] für Anwendungsentwicklung. In dieser Episode geht es um eine weitere Lernzielkontrolle zum Thema Objektorientierung. Viel Spaß!

[0:15] Hallo und herzlich willkommen zur 44. Episode des Anwendungsentwickler-Podcasts.

[0:26] Mein Name ist Stefan Mackel und heute kommt Nummer 2 meiner Lernzielkontrollen zum Thema Objektorientierung.

[0:33] Beim letzten Mal, was ja schon jetzt etwas länger her ist,...