Pseudocode in schriftlichen IHK-Prüfungen der IT-Berufe – IT-Berufe-Podcast #195

Um die Relevanz von Pseudocode-Aufgaben in den IHK-Prüfungen für
Anwendungsentwickler:innen, aber auch für Systemintegrator:innen,
und wie man sie am besten löst geht es in der
einhundertfünfundneunzigsten Episode des IT-Berufe-Podcasts.
Inhalt

In dieser Episode des IT-Berufe-Podcasts thematisiere ich
Pseudocode-Aufgaben, die häufig Teil der schriftlichen
IHK-Prüfungen sind, und das nicht nur für
Anwendungsentwicklerinnen, sondern auch für andere
Fachinformatiker und insb. Systemintegratoren. Ich gehe darauf
ein, warum diese Aufgaben so zentral für die IT-Ausbildung sind
und welche Relevanz sie für die Prüfenden haben. Die grundlegende
Idee hinter den Pseudocode-Aufgaben ist es, das algorithmische
Denken der Prüflinge zu fördern und zu prüfen. Mein Ziel ist es,
dir zu helfen, dich optimal auf solche Prüfungen vorzubereiten.


Ich beginne damit, die Bedeutung von Pseudocode in den
IHK-Prüfungen zu erläutern. Pseudocode stellt sicher, dass ein
allgemeines Verständnis der Programmierung abgefragt wird,
unabhängig von spezifischen Programmiersprachen. Dies ist
wichtig, da die Prüfer in der Lage sein müssen, die Lösungen zu
verstehen, egal welche Programmiersprache verwendet wird. Ich
erkläre die grundlegenden Bausteine des Pseudocodes sowie die
Anforderungen an die Korrektur durch die Prüfer.


Im weiteren Verlauf bespreche ich Strategien, um Pseudocode
effektiv zu schreiben. Ich gebe dir Empfehlungen, wie du deine
Lösungen strukturieren und formulieren kannst, um die maximale
Punktzahl zu erzielen. Dabei sind klare Einrückungen und der
Verzicht auf komplizierte Syntax entscheidend. Es wird auch
geraten, grundlegende Algorithmen zu verwenden und keine
spezifischen Features aus einer bestimmten Programmiersprache zu
nutzen.


Neben der technischen Ausführung gehe ich auch auf die
psychologischen Aspekte der Prüfungsvorbereitung ein. Ich
ermutige dich, alte Prüfungen zu bearbeiten und regelmäßig zu
üben, um ein Gefühl für die Aufgaben zu bekommen. Feedback von
Ausbildern oder KI kann dir helfen, deine Fähigkeiten
weiterzuentwickeln und häufige Fehler zu vermeiden. Ich teile
häufige Problemstellungen, die in der Vergangenheit in Prüfungen
aufgetreten sind, und zeige, wie du diese vermeiden kannst.


Abschließend lege ich großen Wert auf die Notwendigkeit, ein
starkes algorithmisches Verständnis zu entwickeln. Der Fokus
sollte nicht darauf liegen, die perfekte Programmiersprache zu
beherrschen, sondern darum, Probleme effizient zu lösen und zu
verstehen, welche Algorithmen und Logiken hinter den Aufgaben
stehen. Ich hoffe, dass diese Episode dich inspiriert und dir
hilft, dich optimal auf deine bevorstehenden Prüfungen
vorzubereiten.
Wie schreibt man Pseudocode?

In letzter Zeit habe ich von vielen Prüflingen die Frage gestellt
bekommen, ob ich nicht eine Einführung in das Schreiben
von Pseudocode geben könnte. Ich frage dann immer direkt
zurück, was denn so schwierig an Pseudocode sei. Ich würde für
die Programmieraufgaben in der Abschlussprüfung immer Pseudocode
verwenden und niemals eine grafische Darstellung wie das
Aktivitätsdiagramm. Die Diagramme sind meist deutlich aufwändiger
zu erstellen und bei Fehlern sehr schwer zu korrigieren. Mit
Pseudocode ist das deutlich einfacher. Dennoch scheinen viele
Azubis Probleme mit Pseudocode zu haben.
Standards

Erst durch eine Mail eines Zuhörers habe ich erfahren, dass es
sogar Standards für Pseudocode gibt (z.B. Jana, Pascal-Style oder
nach Leierson, siehe Pseudocode). Ich habe weder in meiner
eigenen Prüfung noch in der Prüfungsvorbereitung mit meinen
Azubis das Thema Pseudocode jemals intensiv behandelt. Ich
empfehle immer, anstatt sich eine eigene Syntax für den
Pseudocode auszudenken, einfach normalen Code in
der Prüfung zu schreiben.


Da es für Pseudocode keine allgemeinverbindlichen Vorgaben in der
Prüfung gibt, kannst du auch einfach „echten“ Quellcode in
irgendeiner Programmiersprache verwenden. Wichtig ist, dass die
Prüfenden verstehen, was du erreichen möchtest. Im Zweifel
verstehen Prüfende das mit einer echten Programmiersprache sogar
besser, als wenn du erzwungenen Pseudocode, den du dir selbst
ausgedacht hast, verwendest.
Meine Empfehlung

Um dir die Arbeit etwas zu erleichtern, lass einfach alle
geschweiften Klammern weg. Auch sonstige Syntaxelemente wie
Semikolons am Ende der Zeile sind überflüssig.
Achte darauf, dass dein Programm gut zu verstehen ist und
überfrachte den wenigen Platz, den du auf dem Lösungsbogen zur
Verfügung hast, nicht mit Textelementen, die zur eigentlichen
Logik nichts beitragen.


Fokussiere dich stattdessen darauf, die gestellte Aufgabe zu
lösen, also den Algorithmus abzubilden. Niemand
interessiert sich in der Prüfung dafür, ob du die Syntax einer
Programmiersprache beherrschst. Das ist nur Handwerkszeug. Deine
eigentliche Fähigkeit, die du unter Beweis stellen musst, ist das
Lösen von Problemen.


Ich bringe meinen Auszubildenden die Programmierung meist erstmal
bei, indem sie Aufgaben auf Papier lösen sollen. Wenn du z.B.
nicht einmal mit einem Bleistift auf einem Blatt Papier die
Quadratwurzel einer Zahl berechnen kannst, wie willst du es dann
einem Computer beibringen? Du musst das Problem
verstanden haben, und wissen, wie man es lösen kann.
Wenn du diesen Algorithmus in deinem Kopf hast, kannst du ihn
auch in ein Programm überführen. Die konkrete Syntax, mit der du
dies tust, ist dann irrelevant. Und darum geht es in der Prüfung.


Meine ganz einfache Empfehlung ist also: Benutze Java,
und lass alle unnötigen Elemente weg. Also Klammern,
Semikolons und so weiter. Aber achte auf eine korrekte
Einrückung!
Beispiel

Aus diesem echten Java-Programm:
public int berechneAlter(Date datum, Date geburtsdatum) { int
alter = datum.getYear() - geburtsdatum.getYear(); if
(datum.getMonth() < geburtsdatum.getMonth()) { alter--; } else {
if (datum.getMonth() == geburtsdatum.getMonth()) { if
(datum.getDay() < geburtsdatum.getDay()) { alter--; } } } return
alter; }

Wird dieser „Pseudocode“:
int berechneAlter d, g alter = d.year - g.year if d.month <
g.month alter-- else if d.month == g.month if d.day < g.day
alter-- return alter

Das könnte schon fast als Ruby-Code durchgehen!
Fazit

Da Pseudocode nicht standardisiert ist, kannst du in der
Abschlussprüfung irgendeine Programmiersprache verwenden, die dir
gut bekannt ist und in der du dich wohlfühlst.
Konzentriere dich auf das Lösen des Problems und die
nachvollziehbare Beschreibung deiner Problemlösung. Dann werden
die Prüfenden dir alle notwendigen Punkte geben.
Pseudocode vs. grafische Darstellung

In so ziemlich allen schriftlichen IHK-Prüfungen der letzten
Jahre (vgl. Themen der schriftlichen Prüfungen) gab es mindestens
eine „Programmieraufgabe“. Es sollte also ein Algorithmus für ein
beliebiges Problem auf dem Papier „programmiert“ werden. Da
Programmieren das Tagesgeschäft aller Anwendungsentwickler:innen
ist, finde ich diese Aufgaben auch absolut sinnvoll. Allerdings
kommen in der Praxis häufig einige Fragen auf, wenn es um die
Beantwortung dieser Aufgaben geht.


Spoiler: Beantworte Programmieraufgaben immer mit
Pseudocode und nie mit einem Aktivitätsdiagramm (oder früher
Struktogramm oder Programmablaufplan).
Programmieraufgaben

Die Programmieraufgaben in der Abschlussprüfung haben meist einen
komplexeren Algorithmus zum Inhalt (z.B. eine
Prüfzifferberechnung, den Druck einer Kundenliste usw.). Daher
sind die Aufgaben zeitintensiv und bringen viele Punkte (meist 25
für einen einzigen Algorithmus). Hin und wieder gibt es auch
„kleinere“ Algorithmen (z.B. das rekursive Berechnen einer
Quersumme) für weniger Punkte.


Auf das konkrete Thema der Aufgaben kann man sich natürlich nicht
im Vorfeld der Prüfung vorbereiten, da die Inhalte
(logischerweise) geheim sind. Aber gemein ist den Aufgaben immer,
dass man sie entweder mittels Pseudocode oder einem
Aktivitätsdiagramm lösen kann. Niemals werden die Aufgaben eine
bestimmte Programmiersprache fordern, da es nicht die eine
Sprache gibt, die alle Azubis beherrschen. Selbst Java ist nicht
überall Standard, da z.B. auch C# oder Pascal an Berufschulen
gelehrt wird.


Es muss also prinzipiell jedem Prüfling möglich sein, die Aufgabe
zu lösen. Daher werden standardisierte Darstellungsformen wie das
Aktivitätsdiagramm vorgegeben. Früher waren es mal Struktogramm
(bzw. Nassi-Shneiderman-Diagramm) und Programmablaufplan, für die
es sogar DIN-Normen gibt.


Welche Variante man wählt, hat keine Auswirkung auf die Bewertung
durch die Prüfenden. Mit jeder Darstellungsform kann man die
komplette Punktzahl holen. Warum ist es nun aber sinnvoll, nicht
die Diagrammform zu verwenden, sondern Pseudocode zu schreiben?
Meiner Meinung nach sprechen drei Punkte gegen die Diagramme.
Diagramme sind sehr zeitaufwändig.

Die Diagramme vernünftig zu zeichnen kostet Zeit. Anstatt ein
simples if zu schreiben, muss zusätzlich ein schönes Kästchen
drumherum gemalt und auf genügend Platz für die Folgeelemente
geachtet werden. Da die Programmieraufgaben ohnehin schon sehr
zeitaufwändig sind und die allermeisten Prüflinge eher zu wenig
als zu viel Zeit in der Prüfung haben, rate ich daher von
aufwändigen Zeichnungen ab.
Diagramme sind nur umständlich nachträglich zu korrigieren.

Viele Prüflinge erstellen unter Zeitdruck nicht beim ersten
Versuch die korrekte Lösung. Das ist auch kein Problem, wenn man
am Ende der Prüfungszeit noch einmal korrigierend durch die
Aufgaben geht. Allerdings lassen sich Diagramme im Nachhinein nur
schwierig korrigieren. Einen vergessenen switch-Branch
nachträglich ins Diagramm zu fummeln, kann nur nach hinten
losgehen. Das Diagramm sieht danach hässlich aus, ist vielleicht
nicht mehr verständlich und die Syntax ist ggfs. auch nicht mehr
korrekt. Und mit Sternchen die fehlenden Teile im Diagramm zu
kennzeichnen und auf der nächsten Seite nachzureichen trägt auch
nicht zur Lesbarkeit bei. Das verwirrt die Prüflinge dann meist
noch zusätzlich und sie verstehen ihre eigene Zeichnung nicht
mehr.
Es gibt ggfs. Punktabzug für eine falsche Syntax.

Die grafischen Darstellungsformen sind standardisiert. Das heißt,
es gibt eine verbindliche Syntax für sie. Und als Prüfende:r muss
ich davon ausgehen, dass diese Darstellung bekannt ist. Wenn sie
dann nicht standardkonform umgesetzt wird, weil z.B. ein Kreis
anstelle eines Rechtecks verwendet wird, muss das eigentlich zu
Punktabzug führen. Die Prüfenden drücken sicherlich auch mal ein
Auge zu, aber diese potentielle Fehlerquelle kann man sich
sparen, indem man keine Diagramme nutzt.
Pseudocode

Sich gegen die Diagramme zu entscheiden, heißt, sich für
Pseudocode zu entscheiden. Die Nachteile der Diagramme sind seine
Vorteile:


Pseudocode ist schnell zu schreiben.

Pseudocode kann schnell und einigermaßen lesbar korrigiert
werden.

Pseudocode ist nicht standardisiert und so ziemlich jede
denkbare Syntax ist erlaubt.



Der Vorteil für die Prüflinge beim Einsatz von Pseudocode ist
ganz klar, dass man ihn fast „runterprogrammieren“ kann, wie man
es aus der täglichen Arbeit gewohnt ist. Normalerweise wird z.B.
kein Azubi Probleme mit der Definition einer for-Schleife haben.
Und wenn man die Sytax aus der eigenen Programmiersprache kennt,
kann man diese 1-zu-1 verwenden. Da Pseudocode wie gesagt nicht
standardisiert ist, ist jede „echte“ Programmiersprache auch als
Pseudocode verwendbar. Einfach die Klammern weglassen, um noch
mehr Zeit zu sparen, und fertig ist der Pseudocode!


Allerdings wäre ich vorsichtig mit zu speziellen
Sprachkonstrukten. Die Block-Syntax von Ruby oder das Pattern
Matching aus F# würde ich nicht als allgemein bekannt bei den
Prüfern voraussetzen. Also reduziere deinen Pseudocode auf die
guten alten Bestandteile: Sequenz, Verzweigung, Wiederholung.
Alle Aufgaben sind mit diesen Mitteln lösbar.
Fazit

Ich empfehle meinen Azubis grundsätzlich, Programmieraufgaben mit
Pseudocode zu beantworten und keine komplizierten,
zeitaufwändigen und schwer zu korrigierenden Diagramme zu
zeichnen.
Links

Permalink zu dieser Podcast-Episode

Die perfekte IHK-Prüfung (mein Online-Kurs zur Vorbereitung
auf die schriftliche IHK-Prüfung)

Project Euler (kleine kniffelige Programmierprobleme zum
Üben)

Transkription der gesamten Episode

[0:04] Herzlich Willkommen zum IT-Berufe-Podcast, dem Podcast
rund um die Ausbildung in den IT-Berufen. In dieser Episode geht
es um Pseudocode-Aufgaben in der schriftlichen IHK-Prüfung. Viel
Spaß!


[0:20] Hallo und herzlich Willkommen zur 195. Episode des
IT-Berufe-Podcasts. Mein Name ist Stefan Macke und heute geht es
um eines meiner Lieblingsthemen in den schriftlichen Prüfungen.
Und Lieblings in Anführungszeichen, bitte verstehen. Und zwar
geht es um Pseudocode-Aufgaben in der IHK-Prüfung. Und wenn du
dich jetzt fragst, ist das nicht nur für
Anwendungsentwicklerinnen relevant? Nein, das ist für viele
IT-Berufe interessant und vor allem für die FISIs, die
Systemintegratorinnen. Die haben das nämlich auch relativ häufig
in ihrer Abschlussprüfung Teil 2 tatsächlich. Hätte ich gar nicht
so erwartet. Aber da gibt es relativ oft Aufgaben, so Skripte mal
dies und das. Bau mal einen kleinen Mini-Algorithmus 4XY hier,
keine Ahnung, in der Automatisierung, Netzwerk oder so etwas. Und
im Prinzip sind das die gleichen Aufgaben wie für
Anbietungsentwickler, plus vielleicht vom Umfang her nicht ganz
so groß. Aber die geben auch doch durchaus ganz schön vier Punkte
und kommen relativ häufig vor in der API 2. Hatte ich so auch gar
nicht auf dem Zettel, dass das so ist. Und für die
Anwendungsentwicklerin ist das natürlich Brot und Butter in der
API 2. Pseudocode kommt ja wirklich in, also meines Wissens nach
bislang in jeder API 2 dran, entweder im ersten oder zweiten
Teil, also dem Entwickeln von Algorithmen oder dem Plan eines
Softwareprodukts eher im zweiten Teil Entwickeln von Algorithmen.


[1:34] Passt ja auch irgendwie zum Titel der Prüfung, logisch.
Aber auch in der AP1 sogar kann Programmierzeug drankommen. Mit
dem neuen Prüfungskatalog 2025 wurde das ja nochmal so ein
bisschen verschärft, dass man, also was heißt verschärft nicht,
es wurde genauer, detaillierter spezifiziert, sagen wir mal so,
was da abgefragt werden soll und was nicht. Haben so ein paar
relativ abstrakte Sachen rausgenommen. Ich glaube, Vererbung oder
sowas bei der Web-Dorientierung, das ist nicht mehr so
interessant. Aber dafür die Grundlagen der Programmierung, die
sind für alle IT-Berufe in der AP1 dran und werden da abgefragt.
Und dann ist halt die Art der Aufgaben, wie man das abfragt,
eigentlich immer eine Pseudocode-Aufgabe.


[2:14] Meistens kann man dann, wenn man so einen Algorithmus
formuliert, auch noch eine Alternative wählen. Früher waren das
immer Struktogramme zum Beispiel. Die sind aber jetzt
rausgeflogen. Das würde man jetzt also durch ein
Aktivitäts-Zirgramm der UML machen. Komme ich aber später nochmal
darauf, warum ich das vielleicht nicht empfehlen würde. Und
deswegen soll es heute um den Pseudocode gehen. Ist für alle
IT-Berufe relevant, für FISIs und FIAEs, sogar für die AP2
höchstgradig relevant. Und ja, ich werde so oft nach dem Thema
gefragt, wie man sich da vorbereiten kann, weil viele damit echt
ein Problem haben mit diesen Aufgaben. Und deswegen dachte ich
mir, ich nehme jetzt endlich mal was dazu auf. So meine
allgemeine Empfehlung, wie gehe ich mit Pseudocode-Aufgaben um
und wie hole ich da das Maximum vielleicht an Punkten raus, wie
bereite ich mich da vor und so weiter. Darum soll es heute gehen.
Und ich habe das mal so ein bisschen strukturiert. Wir fangen mal
ganz vorne an. Warum gibt es überhaupt diese Pseudocode-Aufgaben?
Warum werden die in der ERK-Prüfung abgefragt? Schauen wir uns
mal ganz kurz ein Beispiel an, an dem wir uns dann so ein
bisschen vielleicht später meine Erklärung immer wieder mal
anschauen. Und dann geht es darum, was man überhaupt können muss
für diese Pseudocode-Aufgaben. Also welche Teile von
Programmierung sollte man sich da vielleicht anschauen. Und dann
gucken wir uns mal an, was der Prüfungskatalog genau dazu sagt,
wie das eigentlich in der Prüfung abgefragt werden soll. Und dann
schauen wir uns an, was Pseudocode eigentlich ist, wie man den
schreibt. Gibt es dafür Standards? Wie muss der aussehen? Und
dann kommen wir auch schon zu meiner Empfehlung, wie ich das in
der Prüfung schreiben würde. Und ja, dann nochmal, wie gerade
schon angeteasert, Alternativen. Warum nicht einfach ein
Aktivitäts-Dirgramm zeichnen?


[3:41] Und letzter Part der Episode ist dann, wie lerne ich das?
Wie kann ich mich darauf vorbereiten, auf diese Aufgaben? Weil
halt viele Prüflinge in der Prüfung echt Probleme mit diesen
Aufgaben haben. Und deswegen machen wir ganz am Ende nochmal so
häufige Fehler, die sich da vielleicht einschleichen meiner
Erfahrung nach aus den Prüfungskorrekturen. Ja, das wäre so der
Ablauf für heute. Und weil ich mir vorstellen könnte, dass das
ein bisschen länger dauert, würde ich sagen, gehen wir direkt
mitten rein und starten mal mit dem ersten Part.


[4:06] Warum werden überhaupt solche Pseudocode-Aufgaben in der
IHK-Prüfung abgefragt? Das ist doch völlig weltfremd. Pseudocode,
da muss ich eine neue Syntax lehren. Das ist ja wie eine neue
Programmiersprache. Und warum können die nicht einfach, und hier
bitte Programmiersprache X einsetzen, Python, Java, PHP, C, C
Sharp, was auch immer, in der Prüfung abfragen. Warum muss ich
Pseudocode lernen für die Prüfung? So im Kern ist das so ein
bisschen immer die Frage, die mir gestellt wird. Oder wie kriege
ich es eigentlich hin, dass ich diese Aufgaben richtig verstehe?
Weil zugegebenerweise sind diese Aufgaben relativ lang. Zumindest
in AP2 für Amnesty Mekla können die auch einfach mal eine DIN A4
Seite lang sein. Nur der Beschreibungstext. Und dann kommt die
eigentliche Aufgabe. Also da kann man sich ja schon darüber
streiten, warum jetzt diese Fragen in der Prüfung drankommen. Ich
sage mal meine Meinung zu Beginn, ich finde diese Aufgaben
eigentlich sehr sinnvoll, insbesondere in der
AP2-Anwendungsentwicklung, weil das ja nun mal der Kern unseres
Berufes ist und etwas ausgeweitet auch auf alle anderen
IT-Berufe. Ich behaupte, ein ITler, eine ITlerin, die überhaupt
gar nicht programmieren kann, wird es einfach in ihrem Job schwer
haben. Und das ist ganz egal, ob ich eigentlich Systemintegration
mache.


[5:15] Das ist mal nur ein blödes Beispiel. Aber will ich
wirklich als Systemintegrator 23 neue User, die am 1.8. Anfangen,
per Hand in mein Active Directory eintragen? Oder skripte ich das
vielleicht nicht einfach schnell mit einer PowerShell in 10
Zeilen und dann habe ich das Ding erledigt in 5 Minuten, statt
eine Stunde lang was abzutippen? Ja, also Programmierung ist halt
Dreh- und Angelpunkt vieler Automatisierungsprobleme, die wir in
der IT nun mal sehr häufig haben. Also das ist aus meiner Sicht
Kern unseres Berufs und gerade als Anwendungsentwicklerin
natürlich nochmal mehr, weil das ist ja genau das, was wir lernen
sollen. Ich vergleiche das mal mit so einem Tischler. Der wird
wahrscheinlich heutzutage in der Praxis seinen Tisch auch nicht
mehr from scratch selber zimmern und da fünf Stunden investieren
oder noch länger, sondern der wird wahrscheinlich irgendeiner
Fräse, Säge, was auch immer, einem Programmierauftrag erteilen
und sagt, hier schneiden wir den Tisch und fertig. Aber trotzdem
ist es wahrscheinlich so, und ich habe keine Ahnung von der
Tischler-Ausbildung, um ehrlich zu sein, aber ich könnte mir
vorstellen, dass da irgendwo im Prüfungsanalog steht, ein
Tischler muss ein Stück Holz so abfeilen, ist wahrscheinlich das
falsche Wort, schleifen können, dass man sich da keine Splitter
in den Finger jagt wahrscheinlich. Also so die Basics seines
Berufs, irgendwie Holz schleifen, muss man wahrscheinlich
trotzdem drauf haben, auch wenn man im Endeffekt dann der
Maschine am Ende nur noch sagt, wie das genau gesägt werden soll.
Und so sehe ich es in der Realität auch. Jetzt kann man sagen, so
programmieren müssen wir eh nicht mehr, weil es gibt ja KI, die
macht das für uns. Ja, in großen Teilen sicherlich auch richtig.
Für so kleine Sachen kann ich mir das heute schon perfekt
generieren lassen. Da muss ich gar nicht mehr viel programmieren.


[6:40] Aber was ist denn, wenn irgendwas nicht mehr läuft? Dann
wird es halt ein Problem. Was ist, wenn die Säge nicht richtig
gesägt hat? Dann muss ich halt trotzdem noch mal nacharbeiten.
Und wenn die KI nicht richtig programmiert hat, dann muss ich
halt trotzdem das mal korrigieren, dafür muss ich es verstehen.
Und dann ist jetzt die Frage, wie prüfen wir.


[6:54] Diese Prüflinge in den IT-Berufen algorithmisches
Verständnis haben. Denn genau darum geht es. Und das sage ich
meinen Azubis auch. Das sind jetzt alles
Anwendungsentwicklerinnen. Okay, aber das würde ich anderen
ITlern und ITlerinnen genauso erzählen. Und zwar, unser Job ist
eigentlich nicht Programmieren, sondern Probleme zu lösen. Und
gerade im Zeitalter von KI kann ich vielen, ich war gerade
gestern noch auf einer Jobmesse und zwei Menschen, die ich
angesprochen habe, ob sie nicht eine Ausbildung machen wollen,
haben mir schon gesagt, ja, habe ich mal überlegt, aber die KI
wird das ja alles überflüssig machen. Also ich mache jetzt was
anderes. Fand ich interessant, so als junger Mensch, dass man
schon diese Einstellung hat. Und deswegen würde ich sagen, wenn
man sich nur darauf versteift, eine Programmiersprache perfekt zu
beherrschen, dann macht man sich vielleicht wirklich irgendwann
überflüssig, weil die KI das ganz sicher besser kann. Die kann
viel schneller, besser, umfangreicher diesen Code generieren.
Also so ein bisschen abwertend kann man ja solche Menschen als
Code-Affe bezeichnen. Hier sind die Anforderungen, programmieren
wir das. Und so etwas kann die KI heute schon und es wird auch
immer besser. Also da müssen wir uns nichts vormachen. Aber was
eigentlich unser Job ist als Anwendungsentwicklerin und auch in
den anderen IT-Berufen ist, Probleme zu lösen.


[8:01] Kein Fisi wird dafür bezahlt, dass der Benutzer im Active
Directory anlegt, sondern das Ding dahinter, was das Unternehmen
eigentlich haben will, ist, dass ich ein neuer Mitarbeiter
anmelden kann und mit den Systemen arbeiten kann und Geld
verdienen kann. Zum Beispiel, weil er in SAP irgendwelche
Rechnungen eintragen muss oder so.


[8:16] Das ist immer der Hintergrund. Das dürfen wir nicht
vergessen. Die IT-Berufe sind sehr häufig nicht oder eigentlich
fast nie Selbstzweck, sondern wir sind immer Dienstleister und
Dienstleisterinnen für die Bereiche, die das eigentliche Geld
verdienen. Außer wenn ich jetzt eine Softwareentwicklungsbude
bin, klar, dann verdiene ich Geld mit der Softwareentwicklung,
logisch. Ja, aber in vielen anderen Bereichen sind wir
Dienstleistende für die anderen Mitarbeiter, die eigentlich das
Geld verdienen. So, sage ich mal ganz blöd. Und deswegen sage ich
unseren Anbietungsentwicklerinnen immer, dein Job ist eigentlich
Probleme zu lösen. Und wenn du dieses Problem mit einer
Programmiersprache lösen kannst, super. Aber wenn nicht, dann
such halt was anderes, um das Problem zu lösen. Und das ist
etwas, was uns hoffentlich noch ein paar Jahre von der KI
unterscheiden wird, dass die halt außer Programmieren nicht so
viel kann und vielleicht nicht die Anforderungen genau
analysieren kann, auseinandernehmen kann, nachfragen kann, war
das wirklich so gemeint, was ist mit dieser Unsicherheit, hast du
an diesen Edge-Case gedacht, etc. Und das ist auch heute schon
und wird hoffentlich und vermutlich auch in Zukunft die Aufgabe
von Anwendungsentwicklerinnen bleiben. Und ganz am Ende wird dann
das Zeug in eine Programmier-Sprache gegossen. Und ob ich das
dann selbst programmiere oder der KI sage, dass sie das für mich
programmiert, ist dann am Ende fast egal. Das ist ein Werkzeug
und am Ende muss der Computer das Ding ausführen, was ich mir da
ausgedacht habe. Und genau darum geht es. Was habe ich mir da
eigentlich ausgedacht? Wie will ich dieses Problem lösen, was mir
da gestellt wird? Das wollen wir abprüfen in der Prüfung. Und das
hat nichts mit einer konkreten Programmiersprache zu tun, die
ich, na da gibt es ja heute schon 200 verschiedene von, ja.


[9:45] Sondern ich will wissen, ob dieses grundlegende
Verständnis, wie man bei der Problemlösung vorgeht, ob das
funktioniert, ob das der Prüfling oder die Zuprüfende kann. Darum
geht es bei diesen Aufgaben. Und jetzt müssen wir da irgendeine
Lösung finden, weil wir nicht nur in Deutschland, aber auf der
Welt halt wirklich die 200 oder mehr Programmiersprachen haben.
Da können wir jetzt nicht sagen, diese eine Sprache muss jeder
ITler, jede ITlerin lernen. Das ist nicht möglich und das ist
auch heute nicht so und auch nicht umsetzbar. Deswegen brauchen
wir eine allgemeine Form, um Algorithmen zu formulieren. Und das
ist der Pseudocode. Es geht in der Prüfung nicht darum, dass man
eine Programmiersprache super beherrscht, sondern dass man
irgendwie verständlich machen kann, wie man ein Problem lösen
möchte. Und dafür nimmt man Pseudocode. Wir gehen ja später
nochmal auf einen, wie der genau aussieht. Das spoiler ich jetzt
mal noch nicht. Aber das ist der Kern des Ganzen. Und das muss
man sich immer vor Augen führen. Kannst du ein Problem lösen? Das
sollst du zeigen. Und deswegen fokussiere dich nicht so auf
diesen Pseudocode, der da immer so ein paar Problemchen mit sich
bringt, sondern lies die Aufgabe mal so und versuch zu verstehen,
was ist eigentlich das Problem, was hier gelöst werden soll und
wie würde ich da rangehen. Und wie wir das dann konkret machen,
da gehen wir dann gleich nochmal drauf ein.


[10:54] Und ganz wichtig dabei ist, und deswegen Pseudocode und
nicht eine konkrete Programmiersprache, diese Prüfung wird ja, in
Klammern, noch von Menschen korrigiert. Wie zum Beispiel mir. Ja,
ich bin jetzt seit fast 20 Jahren IHK-Prüfer und habe schon
einige Prüfungen mit korrigiert. Und da ist das ganz wichtig,
wenn du diese Prüfung schreibst, dass der Mensch, der das
korrigiert, das verstehen muss, was du da schreibst. Und wenn du
jetzt eine super komische Programmiersprache benutzt, die kaum
jemand kennt und vor allem der Prüfende nicht, dann wird das ganz
schwierig, deine Antwort zu bewerten. Ja, weil die Person kann ja
gar nicht sagen, ob das jetzt richtig ist. Und jetzt sagen
natürlich alle, ja, aber Java oder Python, das muss ja jeder
kennen. Ja, das sagst du vielleicht, weil du in deiner Bubble, in
deiner Welt das so siehst. Aber es gibt so viele andere
Unternehmen auch in Deutschland, die ITler und ITlerinnen
ausbilden und die teilweise Programmiersprachen einsetzen, davon
hast du noch nie was gehört, ja. Es gibt genug Firmen, die zum
Beispiel ABAP in SAP einsetzen, ja, hat überhaupt nichts, ganz
wenig syntaktisch mit Java, C Sharp oder PHP zu tun, sieht ganz
anders aus, ganz andere Struktur.


[11:56] Ganz andere Möglichkeiten der Sprache, aber es gibt auch
viele noch kleinere Nischensprachen, es gibt immer noch genug
kleine Unternehmen, die zum Beispiel Delphi einsetzen als
Programmiersprache, ja, und, ähm, also wirklich, deswegen so ein
bisschen auch über den Tellerrand mal gucken und nicht sowas
sagen, wie, hey, ich finde das aber doof, dass das nicht in Java,
Python, PHP gemacht wird. Stell dir einfach vor, du bist
tatsächlich nicht der einzige Azubi in Deutschland, der die
IT-Ausbildung macht. Wenn du ein bisschen mein Newsletter
verfolgst, ich habe es vor kurzem rumgeschickt, es gibt, glaube
ich, Stand 2025, 17.000 neue IT-Azubis, die diesen
Ausbildungsvertrag unterschrieben haben. Und 17.000 Menschen in
Deutschland machen diese Ausbildung und die lernen nicht alle die
gleiche Programmiersprache. Ja, das ist einfach so. Wir haben
noch gar nicht von den Berufsschulen geredet, die auch alle
machen können, was sie wollen und das auch tun. Das heißt, es
gibt nicht die eine Sprache, die alle können oder können müssen
und deswegen brauchen wir was anderes und das ist der Pseudocode.
Und wenn ich jetzt aus Prüfersicht da drauf schaue und du haust
mir mit irgendeiner komischen Programmiersprache, die ich noch
nie gesehen habe, eine Lösung dahin, dann kann ich das
wahrscheinlich in großen Teilen verstehen, weil das ist ja alles
kein Hexenwerk normalerweise. Aber wenn da irgendwelche
Spezialitäten drin sind, die ich aus keiner anderen Sprache
kennen kann oder mir herleiten kann, dann ist es halt schwierig,
da einen Punkt für zu geben. Ja, und ich kann nicht bei der
Korrektur der IHK-Prüfung nochmal nebenbei bei Google oder
Chat-GPT recherchieren, was, wie, welche Programmiersprache
macht. Das kann nicht meine Aufgabe sein. Es dauert eh schon
sehr, sehr lange, diese Prüfung zu korrigieren.


[13:18] Also, ganz wichtig für dich, du musst deinen Algorithmus
so formulieren, dass der Mensch, der das Ding am Ende liest, das
verstehen, nachvollziehen und bewerten kann, ob das richtig ist.
Darum geht’s. So, jetzt machen wir zum Einstieg gleich mal ein
Beispiel, auf das ich mich dann vielleicht später immer mal
wieder so ein bisschen fokussieren kann oder referenzieren kann.
Und zwar, das war so, glaube ich, noch nicht in der RK-Prüfung,
das habe ich mir selber ausgedacht. Das ist aber auch keine
Wahnsinnsaufgabe, aber ähnliche Sachen kamen schon mal dran. Und
zwar, berechne doch mal zu einer Zahl die Quersumme. So, das ist
jetzt erstmal die Aufgabenstellung. Und jetzt ist das erste
Problem, ich muss erstmal wissen, was die Quersumme überhaupt
ist. Wenn ich nicht weiß, was die Quersumme ist, kann ich auch
keinen Algorithmus erzeugen, um die Quersumme zu berechnen. Das
heißt, ganz kurze Erklärung und das wäre dann ja in IHK-Prüfungen
natürlich erklärt. Also da wird jetzt nicht irgendwas komisches
vorausgesetzt.


[14:07] Quersumme könnte man jetzt behaupten, dass man das
vielleicht sogar aus der Schule kennen sollte. Aber auch hier,
ganz viele Prüflinge haben ja ganz unterschiedliche Schulbildung,
die sie mitbringen vor der Prüfung. Also normalerweise wird hier
alles erklärt, was man wissen muss, um ein Problem zu lösen. Und
in diesem Fall, die Quersumme, was ist das? Wenn ich mir eine
Zahl angucke, die aus mehreren Ziffern besteht, zum Beispiel die
123, besteht aus den Ziffern 1, 2 und 3. Und wenn ich jetzt diese
Ziffern nehme und aufaddiere, dann ist das die Quersumme der
Zahl. Das heißt, bei 123 habe ich die Ziffern 1, 2, 3. Und wenn
ich 1 plus 2 plus 3 rechne, dann habe ich als Ergebnis 6. Und das
ist die Quersumme der Zahl 123.


[14:46] Und jetzt ist die Frage, wie berechne ich das, indem ich
einen Computer das machen lasse. Weil das wollen wir ja gerade
haben. Wir wollen ja einen Algorithmus formulieren. Ein
Algorithmus, eine allgemeingültige Problemlösungsvorschrift.
Erinnern wir uns daran, was ein Algorithmus noch einmal ist. Und
das muss ich so aufschreiben, dass dann der Computer das
ausführen könnte. Und ich sage dann immer gern zum Einstieg,
versuch das doch mal so zu formulieren, als würde nicht der
Computer da vor dir sitzen, sondern als würde da ein
Grundschüler, eine Grundschülerin sitzen, die jetzt diese Aufgabe
für dich lösen soll. Gehen wir mal davon aus, dass die
Grundschülerin die Basics der Arithmetik beherrscht, also plus
minus mal geteilt und vielleicht noch Modulo und so ein paar
Sachen wie zum Beispiel Arrays scanned und so, wo wir später
nochmal drauf eingehen. Und dann musst du dieser Grundschülerin
sagen, mach jetzt mal dies, das, jenes, um dann am Ende zur
Quersumme zu kommen.


[15:35] Und wenn ich jetzt mal, ich habe ja gerade relativ
schnell einfach formuliert, wie das berechnet wird. Mein anderes
Lieblingsbeispiel, was ich auch jahrelang immer in
Einstellungstests benutzt habe, ist, wie berechnet man das Alter
eines Menschen? Und zwar nicht taggenau, sondern einfach, hey,
wie alt bist du? 43. Okay, ja. Wie kommt man auf dieses Alter
unter Angabe des Geburtsdatums und des Datums, zu dem ich das
Alter berechnen möchte? Also zwei Datumsangaben rein, ein Integer
raus quasi. Und das kann im Alltag gefühlt jeder im Kopf mal eben
so machen. Aber sobald es dann losgeht, dass man das strukturiert
aufschreiben muss, wie man wirklich für zwei beliebige
Datumsangaben das berechnet, fangen echt viele Menschen an zu
schwimmen. Und deswegen finde ich das so wichtig auch, dass man
diesen Skill, sage ich mal, in der IHK-Prüfung prüft, weil das
ist halt das Zentrale für unseren Beruf, dass wir so etwas
können.


[16:23] Aber zurück zur Quersumme. Wie würde ich das jetzt
machen? Ich würde mir das überlegen. Ich habe eine Zahl. Und um
das kurz abzugrenzen, Zahl ist 123. Die Ziffer ist die einzelne
Ziffer dieser Zahl. Also eine Zahl besteht aus mehreren Ziffern.
Da geht es schon los mit der richtigen Nomenklatur. Wie nenne ich
was? Und jetzt wäre die erste Aufgabe, und das ist gleich so ein
bisschen vorgegriffen, wie man Probleme allgemein löst, nämlich
nach dem Divide and Conquer Prinzip, also zerlege und herrsche.
Divide et impera, hieß das glaube ich mal auf Latein, der
geschätzte Herr Julius Caesar hat das damals gemacht.


[16:58] Zerschlage deine Feinde in möglichst kleine Gruppen und
da haust du dann mit dem Hammer drauf und dann am Ende hast du
alles erobert quasi. Und genau so geht es hier auch. Wenn ich
nicht weiß, wie ich eine Quersumme berechne, dann fange ich
erstmal an und zerlege mir das Problem in kleinere Schritte und
die dann wieder in kleinere Schritte und wieder in kleinere, bis
ich irgendwas habe, was ich einfach programmieren bzw.
Durchführen kann. Und die Quasi, wenn wir berechnen, da geht es
erstmal los. Ich brauche die einzelnen Ziffern. Das heißt,
vielleicht wäre der erste Schritt, wie kann ich überhaupt eine
Zahl in ihre Ziffern zerlegen? Und allein dafür gibt es schon
drei verschiedene Varianten, die mir jetzt so einfallen würden,
was man machen könnte. Nur als Beispiel. Ich könnte, und das habe
ich ähnlich schon mal in Prüfungen gesehen, die Zahl, ich gehe
jetzt mal davon aus, dass es ein Integer ist, in einen String
umwandeln und dann zum Beispiel mit einer Schleife durch die
einzelnen Buchstaben, in Anführungszeichen, die dann die Ziffern
sind, durchiterieren. Ja, mit einer Schleife zum Beispiel. Könnte
ich tun. Dann habe ich nur das Problem, dass ich erst in String
umwandeln muss. Ich habe dann aber keine Ziffern, sondern einen
Charakter. Den muss ich wieder in eine Zahl zurückwandeln. Das
ist alles ein bisschen Frickelei, aber es wäre denkbar. Ja, es
gibt auch eine andere Lösung und die würde ich in diesem Fall
bevorzugen und zwar eine mathematische Lösung. Das heißt, wie
kann ich der Reihe nach bei einer Zahl durch ihre Ziffern laufen?


[18:08] Da geht es schon los. Durch Laufen wird wohl irgendwas in
Richtung Schleife sein. Ich könnte es aber auch anders lösen. Ich
muss ja nur was wiederholen. Ich könnte auch rekursiv oder so
arbeiten. Das ist erstmal ganz egal. Sondern ich muss erstmal
eine Idee haben, wie ich das Problem überhaupt löse. Und wenn ich
jetzt sage, ich zerlege die Zahl in ihre Ziffern und dann gehe
ich jede einzelne Ziffer durch und… Ach ja, die muss ich ja
aufsummieren. Ah, da brauche ich also noch irgendwas, wodrin ich
mir diese Summe merke. Ah, nochmal zurück zum Reißbrett. Nummer
1.


[18:35] Definiere eine Variable, die Summe heißt und
initialisiere sie mit 0. Das ist unser Startwert. Dann gehe jede
einzelne Ziffer der Zahl durch. Und addiere die Ziffer auf die
Summe. Und als letztes, gib die Summe zurück. So, das wäre zum
Beispiel ein Algorithmus für die Quersumme. Wenn man jetzt aber
genau reinguckt, reicht das für die Prüfung noch nicht aus, weil
dieses Lauf mal durch die Ziffern der Zahl, ja, wie geht das denn
jetzt? Also da gibt es, wie gesagt, drei verschiedene
Möglichkeiten, die mir so ad hoc einfallen, die mit dem String
habe ich gerade erklärt.


[19:06] Da geht es jetzt noch mal tiefer rein. Dieser Teilschritt
ist noch nicht genau genug, weil du kannst zum Beispiel vielen
Programmiersprachen nicht einfach sagen, hier hast du ein
Integer, lauf mal die Ziffern durch. Bei einem String die Stellen
durchlaufen, okay. Bei Integer die Ziffern durchlaufen, gibt es
in keiner mir bekannten Sprache eingebaut. Vielleicht mit
Libraries oder so.


[19:27] Und dieses Problem musst du jetzt selber lösen. Wie
würdest du das machen, wenn man dir eine Zahl gibt? Wie läufst du
durch die Ziffern? Und wie gesagt, du könntest das mit dem String
machen oder du könntest es mathematisch machen. Und ich hatte
schon gesagt, die basic arithmetischen Operationen, die sollten
dir was sagen. Und die letzte, die ich aufgeführt habe, war der
Modulo. Also Division mit Rest, die dir den Rest liefert. Und das
kann man zum Beispiel hervorragend machen bei Integerzahlen. Da
könntest du nämlich einfach Modulo 10 rechnen. Und Überraschung,
dann kriegst du im Prinzip die letzte Ziffer der Zahl. Du gehst
also nicht von vorne nach hinten durch die Zahl, sondern von
rechts nach links. Wenn du eine Zahl Modulo 10 rechnest, teilst
du die Zahl durch 10 und dir wird der Rest gegeben. Und wie du
vielleicht noch aus der Schule kennst, jedes Vielfache von 10 ist
natürlich durch 10 teilbar. Das heißt, ab der zweiten Stelle der
Zahl ist alles, was links noch kommt, definitiv durch 10 teilbar.
Aber nur das, was ganz, ganz hinten steht, die letzte Stelle, die
ist nicht durch 10 teilbar, weil die ist ja kleiner als 10. Da
passt die 10 nicht rein. Das heißt, wenn du bei irgendeiner
ganzen Zahl Modulo 10 rechnest, bekommst du immer die letzte
Stelle der Zahl. Weil alles vor der letzten Stelle ist durch 10
teilbar und fällt damit weg.


[20:39] Beispiel 123 Modulo 10, das Ergebnis ist 3.


[20:43] 127 Modulo 10, das Ergebnis ist 7. Das heißt, du könntest
jetzt schon mal mit einer mathematischen Operation, die relativ
basic ist, Modulo 10. Das ist eine Anweisung, die kannst du in
jeder Programmiersprache so schreiben. Das ist eine Zeile Code,
die kannst du auch nicht weiter runterbrechen und musst du auch
nicht. Und das wäre jetzt der Ansatz zum Beispiel, um an die
letzte Stelle zu kommen. Und jetzt musst du nur das nächste
Problem lösen, wenn ich die letzte Stelle ermitteln kann. Wie
kann ich denn jetzt von der ganzen Zahl diese letzte Ziffer so
abschneiden, dass nur noch die übrigen Ziffern überbleiben? Weil
wenn ich das jetzt auch noch kann, dann kann ich den Algorithmus
ja quasi wieder von vorne starten. Nimm die letzte Ziffer,
schneid die letzte Ziffer ab. Nimm die letzte Ziffer, schneid die
letzte Ziffer ab. Und so lange, bis es keine Ziffer mehr gibt.


[21:25] Und das Schöne dabei ist, wenn du ein bisschen Mathematik
beherrschst, kannst du die entsprechende Gegenoperation zum Modul
nehmen, nämlich die Division, div heißt das in vielen Sprachen
oder ganz normal einfach der geteilt durch Strich, das ist
nämlich in so ziemlich jeder Sprache, die ich kenne, die
ganzzahlige Division. Das heißt, wenn du ein Integer geteilt
durch 10 rechnest, dann liefert der nicht als Ergebnis eine
Kommazahl, sondern er schneidet den Kommateil ab, weil deine Zahl
und 10 beides Integers sind. Und Integer geteilt durch Integer
wird nicht magischerweise ein Double oder ein Float, sondern
bleibt ein Int. Das heißt, es wird einfach die Nachkommastelle
abgeschnitten, sozusagen. Und wenn du eine Zahl durch 10 teilst,
ist das ja nichts anderes als das Komma, um eine Stelle zu
verschieben. Wenn du 123 durch 10 teilst, kommt raus, 12,3. Das
heißt, das Komma ist einfach 1 nach links gewandert. Und wenn du
bei dieser Division aber jetzt die Nachkommastelle einfach
abschneidest, bleibt als Ergebnis 12 aus 123 geteilt durch 10
wird 12. Und Überraschung, das sind genau die ersten beiden
Ziffern der Zahl, 1 und 2. Das heißt, mit Modulo 10 kommst du an
die 3 und mit geteilt durch 10 kommst du an die 1 und 2, also die
verbleibende Zahl. Und damit kannst du wieder von vorne starten.
Und dieser kleine Trick Führt jetzt dazu, dass unser Algorithmus
so aussehen könnte. Definiere eine Variable mit dem Namen Summe
und initialisiere sie mit 0.


[22:48] Dann, solange die Zahl nicht 0 ist, mach folgendes.


[22:55] Zu addierender Wert gleich Zahl modulo 10.


[23:00] Addiere den zu addierenden Wert auf die Summe. Setze die
Zahl auf Zahl geteilt durch 10.


[23:07] Und das war der Algorithmus. Ganz am Ende müsstest du
noch sowas sagen wie gib Summe zurück oder so, damit die auch
zurückkommen. Aber das war’s. Was mir gerade einfällt, noch
besser wäre, wenn du die Variable Quersumme genannt hättest und
nicht Summe. Dann wäre das sogar noch ein bisschen sprechender.
Das heißt, die Quersumme wird durch eine Schleife, die so lange
läuft, wie die Zahl noch stellen hat, ganz blöd gesagt, solange
sie nicht Null ist, immer wieder addiert durch den Wert der
rechtesten Ziffer. Und das alles nur mit Mathematik, ohne
String-Gefrickel oder so etwas.


[23:39] Hätte man das so lösen müssen? Nein, komme ich später
auch nochmal drauf. Es geht nicht darum, die perfekte, super
optimierte, tolle mathematische Lösung zu finden, sondern einfach
erstmal nur das Problem zu lösen. Das heißt, wenn du es lieber
mit einem String machst und sowas machst wie, ich versuche es
nochmal, definiere eine Variable mit dem Namen Quersumme und
initial siehe sie mit 0, dann wandle die Zahl in einen String um
und für jeden Buchstaben in der Zahl, wandle den Buchstaben in
eine Zahl um, addiere diese Zahl auf die Quersumme und geh zum
nächsten Buchstaben. Das wäre es. Könnte man auch machen. Da muss
man jetzt nur ein bisschen aufpassen, wie gesagt, mit der
Typumwandlung dazwischen und so weiter. Aber Lösung wäre das
trotzdem, die funktioniert. Das heißt, für diese Aufgaben als
allererstes mal den Tipp, du musst überhaupt erstmal eine Lösung
finden. Das wäre erstmal das Allerwichtigste. Wenn du im Kopf
dieses Problem nicht lösen kannst, wenn du nicht erklären kannst,
wie man die Quersumme bildet, Dann brauchst du es auch nicht zu
programmieren, weil du weißt gar nicht, wie du es programmieren
musst, wenn du keine Lösung hast. Das heißt, als allererstes
suchst du dir eine funktionsfähige Lösung, egal ob die
String-Geschichte oder die Modulo-Geschichte, völlig egal.
Hauptsache, du hast erstmal eine Lösung im Kopf und dann
überlegst du dir, wie du die als Algorithmus formulierst und das
mit Pseudocode. Und das gucken wir uns im Nachgang jetzt weiter
an, wie man das jetzt genau macht.


[24:56] So, kurzer Mini-Exkurs, was man so an Kenntnissen für die
IHK-Persuchung mitbringen sollte, für die Aufgaben, die dort
gestellt werden, üblicherweise auch schon für die AP1. Im Prinzip
ist der Kern hier algorithmisch. Das heißt, es geht uns nicht um
funktionale Programmierung, Objektorientierung, irgendwelche
tiefer gehenden Konzepte, sondern um die Basisbestandteile von
Algorithmen. Und wenn du das noch nie gehört hast, es gibt drei
Bestandteile, aus denen man Algorithmen zusammensetzt und wenn
man die kann, dann kann man jedes Problem, was sich berechnen
lässt, auch lösen. Man braucht keine fancy, coolen zusätzlichen
Sprachfeatures, es geht mit diesen drei Basic-Sachen. Und die
definieren so ganz nebenbei auch, ob man überhaupt von einer
Poamiersprache redet, weil eine Poamiersprache braucht alle diese
drei Möglichkeiten, sonst darf sie sich nicht als solche
bezeichnen. Und diese drei Algorithmen-Bausteine sind Sequenz,
Verzweigung und Wiederholung. Sequenz bedeutet der Reihe nach
etwas ausführen, also mach 1, mach 2, mach 3. Der Reihe nach von
oben nach unten abarbeiten.


[25:54] Verzweigung ist eine Fallunterscheidung, das heißt
entweder mache ich das eine oder ich mache das andere auf Basis
einer Entscheidung. Zum Beispiel, wenn das Alter größer ist als
18, dann mache irgendwas, ansonsten mache was anderes.
Fallunterscheidung. Und dann habe ich noch eine Wiederholung,
also mache Dinge mehrfach hintereinander. Immer wieder
gleichartig und dann aber 20 mal das Gleiche. Das wäre eine
Wiederholung. So, und wenn ihr gut aufgepasst hast, habe ich
jetzt hier nicht gesagt, wir haben Sequenz, If und Vorschleife,
sondern ich nenne bewusst die allgemeinen Varianten Verzweigung
und Wiederholung. Denn nicht in jeder Programmiersprache gibt es
If und Vor, sondern das kann man auch anders lösen. Also gerade
bei der Wiederholung, da gibt es nicht nur Schleifen, wie man
Dinge wiederholen kann, sondern es gibt zum Beispiel auch noch
die Rekursion. Auch mit Rekursion kann man Dinge wiederholen. Es
gibt sogar noch ein drittes, nämlich mit Go-Tos. Die allerersten
Programmiersprachen, die hatten weder Schleifen noch Rekursion.
Da wurde mit Go-To gearbeitet. Also geh drei Zeilen wieder hoch,
geh drei Zeilen wieder hoch. Das ist auch eine Wiederholung. Das
heißt, ich bin hier ein Freund davon, die allgemeinen Sachen zu
formulieren, denn manchmal kommen in der IHK-Prüfung auch
rekursive Algorithmen dran. Und da ist der rekursive Aufruf das
Mittel der Wahl, um Dinge zu wiederholen. Von daher, diese
allgemeinen Sachen braucht eine Programmiersprache und die musst
du kennen für Pseudocoach.


[27:11] Mehr ist es normalerweise nicht. Das heißt, ich habe
üblicherweise irgendwie so ein paar Fallunterscheidungen, da ist
da mal eine Wiederholung drin. Also meistens ist es eine Schleife
und meistens ist es natürlich ein If, aber auch bei der
Verzweigung. Es kann ja auch mehr Ververzweigungen geben. Zum
Beispiel mit einem Switch oder so etwas.


[27:24] Und wenn ich jetzt noch einen Schritt weiter gehe,
Verzweigung, könnte ich sogar eine Objektorientierung Polymorph
lösen. Also es gibt auch hier, Verzweigung, Wiederholung kann ich
auf verschiedene Arten umsetzen. Das ist nicht immer nur ein
If-Statement und immer nur die Vorschleife. Es gibt auch andere
Möglichkeiten.


[27:39] Also das solltest du kennen, Sequenz, Verzweigung,
Wiederholung. Und dann, wie gerade schon erwähnt, so die basic
mathematischen Sachen. Die plus, minus, mal geteilt und Modulo.
Modulo würde ich dringend empfehlen, da solltest du dir unbedingt
angucken, weil das in ganz vielen Aufgaben benötigt wird. oder du
zumindest dir das Leben damit einfacher machen kannst. Und dann
ist es in der IHK-Prüfung häufig so, dass irgendwas mit, Arrays
dran kommt. Wahlweise auch Listen, also irgendwelche, ja, ich
nenne sie mal allgemein Collections.


[28:04] Ja, was wäre denn ein schöner deutscher Begriff? Eine
Liste hört sich dann wieder so an wie so ein List-Interface zum
Beispiel in Java. Das meine ich aber gar nicht. Sondern einfach
eine Liste mit mehreren Elementen. Und ob es jetzt ein Array ist
oder eine List oder eine Array-List oder eine Linked-List oder
so, ist erstmal egal. Sondern du sollst in vielen Aufgaben
zeigen, dass du mit mehreren Elementen umgehen kannst. Und
Spoiler, das machst du fast immer mit einer Schleife.


[28:27] Aber da kommen wir dann vielleicht später nochmal drauf.
Also Arrays, wichtiges Thema. Und dann kann es sein, das ist dann
aber eher für Anbietungsentwickler dann so, dass da ab und zu
auch mal so ein bisschen Objektorientierung, ich sage immer
gerne, so drauf, gestreuselt wird, dass dann zum Beispiel aus dem
Array Sachen rausgefriemelt werden und dann sollen die als Objekt
einer Klasse irgendwie zusammengebaut und instanziiert werden
oder so. So ein kleiner, mini-objektorientierter Anteil. Oder
manchmal sogar funktionale Programmierung eingestreut wird, Das
heißt, in einer Prüfungsaufgabe war sowas wie ein
Sortieralgorithmus und dann sollte das Kriterium, nachdem man
sortiert, flexibel sein. Und das wurde dann mit so einer Art
funktionalen Programmierung gemacht. Das heißt, anstatt hart zum
Beispiel zwei Vornamen zu vergleichen, sollte der Vergleich an
sich über eine Funktion, die hineingegeben wurde, durchgeführt
werden. Das war jetzt von der Syntax her nicht sonderlich
schwierig. Man hätte jetzt auch nicht zwangsläufig funktionale
Programmierung verstehen müssen, um das lösen zu können. Aber
zumindest sind Ansätze zu erkennen, auch diese, wie soll ich
sagen, modernen Sachen in die Programmierung mit reinzugeben.
Weil oft beschweren sich die Prüflinge natürlich, das ist ja
Programmierung wie vor 100 Jahren, so gefühlt.


[29:33] Ja, okay, aber nochmal zurück zum Anfang. Es geht hier
nicht um fancy Programmiersprachen-Features, sondern es geht um
die Basics unseres Berufs, ein Problem zu lösen. Und jedes
berechenbare Problem kannst du lösen mit Sequenz, Verzweigung und
Wiederholung. Du brauchst keine Objekteorientierung, du brauchst
keine Funktionalprogrammierung oder eben, du brauchst nur diese
drei Sachen. Damit kannst du jedes Problem formulieren. Das ist
so, dass das absolute Basic-Wissen, was alle ITlerinnen lernen
sollten, völlig unabhängig von ihrer Programmiersprache.


[30:02] Deswegen, ehrlich gesagt, finde ich es auch gut, dass das
in der Prüfung abgefragt wird und nicht irgendwelche
Hardcore-Modernen in Anführungszeichen Sachen, weil du, wie
gesagt, halt nicht, also selbst wenn du zum Beispiel, wie meine
Azubis auch, Ausbildungen mit Java machst und du natürlich nicht,
hoffentlich, auf Java Version 6 vor 15 Jahren arbeitest, sondern
ein bisschen modernere Sachen machst, kannst du natürlich auch
funktionale Programmiersprachensachen da einbauen. Das ist ja
richtig cool. Das wollen wir auch im Alltag benutzen. Bitte
verstehe mich nicht falsch. Ich erwarte nicht, dass du im Alltag
prozedurales Zeug wie hier mit Verzweigung und Wiederholung
programmierst. Darum geht es nicht. Ich erwarte, oder die
Prüfenden erwarten, dass du einen Algorithmus formulieren kannst.
Und dass du das in einem echten Projekt mit einer echten
Programmiersprache noch cooler lösen kannst, ist ja super. Und
mach das auch gerne. Das freut mich. Und da habe ich auch Bock
drauf. Auf jeden Fall.


[30:48] Nur das ist halt eben nicht Teil der Prüfung. In der
Prüfung sollst du nur zeigen, dass du den Algorithmus formulieren
kannst. Und dafür müssen wir eine Sprache benutzen, die jeder
andere Azubi auch spricht. Ganz blöd gesagt. Und leider macht
nicht jeder Azubi in Deutschland mit der gleichen
Programmiersprache seine Ausbildung und hat schon mal was von
Streams und Optionals und irgendwas gehört. Das ist einfach nicht
so. Und das kannst du jetzt wahlweise ersetzen durch irgendwelche
Sachen in Python,


[31:10] die es vielleicht auch nicht in Java gibt oder so. Es ist
völlig egal, welche Sprache. Wir können uns einfach nicht auf
eine einigen. Und deswegen brauchen wir die absoluten Basics. Und
das ist Sequenz, Verzweigung und Wiederholung. So, das zu dem
Thema. Und jetzt machen wir weiter mit der Frage, was der
Prüfungskatalog denn eigentlich zu der Lösung dieser
Pseudocode-Aufgaben sagt.


[31:33] Da gibt es nämlich relativ exakte Vorgaben, wie man diese
Aufgaben lösen soll. Und da steht extra nochmal erklärt, dass
dort eben nicht in einer bestimmten Programmiersprache
programmiert werden soll. eben genau vor dem Hintergrund, dass
das ja vielleicht für einige Menschen nicht verständlich ist,
wenn sie diese Sprache nicht kennen. Das ist einfach so. Du
kannst auch nicht deine IHK-Prüfung auf Spanisch beantworten,
nicht mal auf Englisch. Das geht nicht. Die Sprache der
IHK-Prüfung ist Deutsch. Und ich weiß, dass man da jetzt selber
drei Stunden drüber diskutieren kann, ob das so richtig ist, weil
wir haben auch viele Menschen, die die Prüfung machen, die
Deutsch nicht als Muttersprache haben. Das ist ein ganz anderes
Problem. Und natürlich wäre das cool, wenn das anders wäre. Ist
aber nicht so. Das heißt, wir müssen uns jetzt, solange die
Prüfung halt so ist, daran orientieren, was da gefragt wird. Und
im Prüfungskatalog steht explizit, der Code soll für Dritte ohne
Kenntnis der verwendeten Programmiersprache lesbar sein. Das
heißt, wenn du zum Beispiel den Teil aus deiner
Java-Programmiersprache nimmst, der relativ sicher von vielen
anderen Menschen auch verstanden werden kann, bist du gut dabei.
Nimmst du aber irgendwelche.


[32:32] Funktionalen, Stream-basierten,
Optional-irgendwas-Sachen, die man nicht sofort verstehen kann,
ist es halt ein Problem. Also, das sagt der Prüfungskatalog.
Dritte ohne Kenntnis der Sprache sollen das verstehen können. Das
ist eine explizite Aussage. Dann steht auch explizit drin, der
Code muss nicht kompilierbar oder ausführbar sein. Das heißt, es
gibt nicht den Zwang, eine richtige Programmiersprache zu
benutzen. Andersherum übrigens, spoiler ich schon mal, schließt
das nicht aus, dass du auch einfach eine Programmiersprache
nutzen kannst. Also du kannst, wenn du willst, deinen ganzen Code
auch in Java schreiben. Das ist überhaupt kein Problem. Du kannst
alle Klammern, alle Semikola, alles da eintragen. Das ist
überhaupt kein Thema, solange Punkt 1 eingehalten wird, dass
Dritte das ohne Kenntnis der Programmiersprache lesen können.
Ganz einfach, ja? Also, das vielleicht schon mal vorweg. Wenn du
Bedenken hast bei diesem Pseudocode, dann schreib es einfach in
der Programmiersprache, die du den ganzen Tag benutzt. Das ist
überhaupt kein Problem. Aber mit ein paar Einschränkungen, zu
denen ich gleich noch komme, Namentlich, dass jeder andere Mensch
das verstehen muss, auch wenn ich noch nicht seit drei Jahren
Python programmiere. Das heißt, hier wieder runtergestrippt auf
die Basics. Sequenz, Verzweigung, Wiederholung. Wenn du das
benutzt aus deiner Sprache, schreibt Python, Java, C-Sharp, PHP,
völlig egal, aber nutzt du irgendwelche fancy Sachen, die die
anderen Leute außerhalb deiner Programmiersprachen-Bubble nicht
kennen, dann kriegst du ein Problem.


[33:52] Also, es muss nicht kompilierbar sein. Gehen wir gleich
auch nochmal bei meiner Empfehlung drauf ein, wie man Pseudocode
schreibt. Ich spoiler schon mal, lass einfach alle Klammern und
Semikolons weg. Muss ja nicht kompilierbar sein, viel zu viel
Schreibarbeit, bringt niemanden weiter, also lass das Zeug weg.
Dann steht sogar explizit drin, Syntaxfehler, wer denn toleriert?
Das heißt, selbst wenn du, keine Ahnung, bei Array.length nicht
length, sondern length schreibst, einfach zwei Buchstaben
vertauscht hast, egal, darum geht es nicht in der Sprache. Wenn
ich erkennen kann, dass du mit length wohl length, also die Länge
meintest, dann ist das okay. Wenn du das auf Englisch nicht so
gut schreiben kannst, kannst du auch sagen, Variable x gleich
Länge des Arrays. Gültiger Absurdokode. Ich muss ja nur
verstehen, dass du auf die Länge des Arrays zugreifen willst. Und
ob du Leng oder Len oder Length oder Length, Hauptsache ich
erkenne, dass es irgendwas mit der Länge zu tun hat. Das ist
wichtig. Also Syntaxfehler werden toleriert.


[34:46] Und dann noch, finde ich, ein wichtiger Punkt,
Kontrollstrukturen wie zum Beispiel durch Einrücken müssen
ersichtlich sein. Das heißt, wenn du sowas wie ein If, eine
Vorschleife und so weiter machst, ich hatte ja eben schon gesagt,
Verzweigung, Wiederholung kann man auch anders machen, aber in 95
Prozent der Fälle wird es ja wahrscheinlich ein If und
wahrscheinlich eine Vorschleife oder eine While-Schleife sein.
Das ist ja klar. Ich will nur darauf hinweisen, dass es auch
andere gibt, aber in den meisten Fällen wird es am Ende doch das
If und wird die Vorschleife. Und dann wäre es durchaus sinnvoll,
dass du den Kopf und den Rumpf der Schleife oder des
If-Statements so absetzt, dass man auch erkennen kann, was wohin
gehört. Das heißt, wenn nach der Schleife oder nach dem If noch
weiterer Code kommt, dann muss der natürlich wieder ausgerückt
werden, damit das nicht so aussieht, als würde er noch in die
Schleife gehören. Solche Sachen müsstest du dann schon machen.
Also wenn wir meinen Tipp von eben nehmen, lass die Klammern weg.
Gut, lass die Klammern weg, aber dann rück auch wieder aus, wenn
die Schleife vorbei ist. Und das habe ich leider auch schon
gesehen in Lösungen in der K-Prüfung, dass Leute einfach immer am
Zeilen anfangen, anfangen zu schreiben. Egal, ob ich gerade in
der dritten verschachtelten Schleife bin oder nicht. Und das ist
natürlich mega schwer nachvollziehbar. Nicht nur für uns als
Prüfende, sondern auch für dich selber. Wenn du es dir selber
nochmal anguckst, so hä, welche Ebene war das jetzt hier? Es
fängt ja alles an der gleichen Stelle an in der Zeile. Das ist
nicht gut. Das heißt, hier steht sogar explizit zum Beispiel
durch Einrücken im Prüfungskatalog. Also mach das einfach. Das
wäre auch gleich mein gespoileter Tipp. Lass die Semikolons und
Klammern weg, aber rück deinen Kram so ein, dass man erkennt, was
wozu gehört.


[36:14] So, das ist also das, was der Prüfungskatalog vorgibt.
Und dann könnte man jetzt ja sagen, gut, dann nehmen wir den
Pseudocode, wie er im Buche steht. Der wird das ja wohl alles
einhalten. Und dann schreibe ich damit die Prüfung.


[36:26] Ja, wäre schön. Leider gibt es keine Definition vom
Pseudocode. Es gibt keine Standard. Es gibt keine Norm. Es gibt
nichts, wo du nachgucken kannst, wie Pseudocode auszusehen hat.
Es gibt verschiedene Varianten, die man auch zum Beispiel bei der
Wikipedia sich mal angucken kann. Da gibt es zum Beispiel die
Jana. Na, das ist ein Pseudocode, der auf Java basiert. Oder es
gibt einen Pascal-ähnlichen Pseudocode. Hast du vielleicht auch
schon mal in Musterlösungen gesehen? Das ist sowas, was immer mit
Beginn und End oder so anfängt, anstatt Klammern zu benutzen. Das
wird relativ häufig zum Beispiel auch in den Musterlösungen
benutzt, würde ich behaupten, diese Pascal-ähnliche Syntax. Ich
habe eigentlich jetzt auch schon extra als Vorbereitung nochmal
die Musterlösungen der letzten Jahre durchgeguckt und das ist mal
so, mal so. Das heißt, auch da nicht mal in den Musterlösungen,
es sind auch gar keine Musterlösungen, sondern ja
Lösungserläuterungen. Ich bringe das immer selber durcheinander.
Man kann nämlich jeden Algorithmus auch anders lösen, als der in
der Musterlösung steht. Aber da kommen wir gleich nochmal drauf.
Wichtig ist aber, dass du nicht mal in den Lösungen einheitliche
Vorschläge hast. Also mal ist es sehr Java-ähnlich, mal ist es
Pascal, mal ist es ganz was anderes. Also es gibt hier keinen
Standard. Und deswegen sage ich auch immer gerne, wenn du keinen
Bock auf Pseudocode hast, dann schreib den Kram in einer
Programmiersprache, die du kennst. Fertig. Das ist gültiger
Pseudocode, weil es keinen Standard dafür gibt, gegen den das
irgendwie gewertet wird. Denk an die Vorgaben, der Prüfer, die
Prüferin muss es verstehen können. Das ist alles. Mehr
Anforderungen gibt es nicht.


[37:50] Und deswegen kommen wir jetzt zu meiner Empfehlung. Was
würde ich dir jetzt für die Prüfung konkret empfehlen? Ich würde
dir ehrlicherweise empfehlen, nimm eine Programmiersprache, die
du kennst, die du jeden Tag benutzt. Wahrscheinlich hast du in
deiner Ausbildung die letzten zwei, zweieinhalb, drei Jahre eine
Programmiersprache hauptsächlich benutzt. Das hoffe ich
zumindest, dass du nicht 27 verschiedene gelernt hast, sondern
hauptsächlich erstmal eine und die dann gut. und mit der kennst
du dich hoffentlich so gut aus, dass du die Syntax, wie soll ich
das jetzt sagen, auswendig, ohne nachzugucken, einfach
runterschreiben kannst. Weil wir haben eben schon gehört, die
Aufgabenstellung ist manchmal eine DIN-A4-Seite lang. Das dauert
einfach extrem lange, diese Aufgaben zu bearbeiten. Als es noch
möglich war, vor der Neuordnung der T-Berufe, habe ich meinen
eigenen Azubis empfohlen, die Pseudogood-Aufgaben zu streichen,
weil die einfach extrem lange dauern, super fehleranfällig sind
in der Lösung. Und ja, also man verballert einfach so viel Zeit
damit. Deswegen war das echt eine Streichaufgabe. Haben viele
Prüflinge auch immer so gemacht. Pseudocode-Aufgaben gestrichen.
Jetzt nach der Neuordnung geht das ja nicht mehr. Das heißt, wenn
du Pseudocode hast, dann musst du es auch lösen. Kommst nicht
drumherum.


[38:55] Deswegen mach dir das Leben nicht noch schwerer mit
irgendeiner Syntax, die du nicht beherrschst, weil du sie nie
benutzt, sondern nimm einfach die Poemiersprache, die du jeden
Tag benutzt. Dann hast du da schon mal ein Problem weniger, wie
du es formulieren musst. Nimm einfach eine Poemiersprache, die du
kennst. Und dann aber mach dir das Leben einfacher. Lass alles
Unnötige, was nicht zum Verständnis beiträgt, weg. Das sind
Klammern oder Ende von irgendwelchen Kontrollstrukturen, sowas
wie if und endif. Das endif zum Beispiel könntest du weglassen.
Die Klammern kannst du weglassen. Die Semikolons am Ende, wenn
das an deiner Sprache nötig wäre, kannst du weglassen. Also
alles, was nicht den Kern, sag ich mal, der Statements in der
Zeile, was du beschreibst, betrifft, kannst du weglassen. Solange
es dann halt noch für Außenstehende verständlich ist. Dann machst
du dir das Leben nicht schwer, weil du kannst es runterschreiben,
du kennst es aus deinem Alltag und lässt aber alles weg, was dich
Zeit kostet. Weil du das ja nicht vergessen auf Papier schreiben
musst und jeder Buchstabe, den du da schreiben musst,
beziehungsweise jedes Zeichen kostet dich Zeit.


[39:56] Dann unbedingt darauf achten, einrücken. Also meine
Empfehlung, statt Klammern oder if and if, einfach einrücken.
Dann ist es offensichtlich und du sparst dir Zeit. Und wie eben
schon gesagt, lass bitte alle coolen Features der Sprache weg.
Ja, ich habe da gleich noch ein paar Beispiele, was ich damit
meine, was ich an der Stelle weglassen würde. Sondern benutze nur
die Basics. Sequenz, Verzweigung, Wiederholung. Ja, und schon bei
Wiederholungen geht es los, dass viele Sprachen so coole, geile
Sachen haben, um noch kürzer, noch prägnanter irgendwie durch was
iterieren zu können. Aber bitte, bitte, der wichtigste Punkt ist,
die Prüfenden müssen das verstehen. Und wenn du irgendeine
Python-spezifische Syntax hast, wo du mit drei Zeichen durch ein
Array laufen kannst, ist das ganz toll. Das darfst du im Alltag
rauf und runter benutzen. Aber bitte nicht in der Prüfung.


[40:46] In der Prüfung geht es darum, verständlich den
Algorithmus zu formulieren. Ich wiederhole mich, weil das so
wichtig ist. Aber ich sehe es halt so häufig in den Prüfungen,
dass Leute das nicht machen. Und deswegen gehe ich halt heute so
darauf ein. Also lass den ganzen coolen, hippen Kram weg. Ich
sage immer so, du sollst hier nicht zeigen, dass du der geilste
Programmierer bist oder die coolste Programmiererin und dass er
alles viel besser kann als die Prüfenden. Sondern du sollst
einfach zeigen, dass du die Aufgabenstellung bearbeiten kannst
und einen Algorithmus formulieren kannst. Fertig. Darum geht es.
Und alles, was du mit den drei Algorithmenbausteinen lösen
kannst, das machst du auch damit und lass die komischen Features
weg.


[41:23] So, letzter Punkt. Meistens sind die Datentypen in der
Prüfung irrelevant. Das heißt, anstatt zu sagen int Quersumme
gleich 0, kannst du auch sagen, definiere Quersumme als 0.


[41:34] Du musst normalerweise keine Datentypen hinschreiben,
weil sie für den Algorithmus sehr oft irrelevant sind. Für die
Quersummen-Aufgabe von eben war es egal. In diesem Fall wird
wahrscheinlich sogar vorgegeben sein. Definieren Sie die folgende
Funktion. Berechne Quersumme in Klammern int x oder so. Dann ist
sogar schon vorgegeben, dass es ein Integer ist. Musste sich um
nichts mehr kümmern. Wenn du aber zum Beispiel den Algorithmus
mit dem Umwandeln in einem String und Durchlaufen der Ziffern
machst, dann sind die Datentypen natürlich schon wichtig, weil du
mit einem String halt nicht rechnen kannst. Das funktioniert
nicht. Das heißt, wenn du dich für eine Lösung entscheidest, wo
du Datentypen spezifische Sachen machen musst, damit es
funktioniert, dann musst du bitte natürlich auch die Datentypen
hinschreiben. Klar, aber für die meisten Algorithmen, die ich aus
Prüfungen kenne, sind die Datentypen völlig irrelevant. Deswegen
kannst du sie weglassen. Also zusammengefasst, ganz blöd gesagt,
stell dir vor, du arbeitest in deiner Programmiersprache, aber
die wäre jetzt auf einmal dynamisch typisiert. Das heißt, du
brauchst keine Datentypen und alles, was unnötig ist, wie
Klammern und Semikolons, kannst du weglassen. So, dann kannst du
das runterschreiben, weil du Syntax kannst, lässt alles weg, was
du normalerweise hinschreiben musst, aber was dich jetzt hier
Zeit kostet. Und Datentypen, egal, weil du sollst ja das Problem
lösen.


[42:50] So, das wäre meine Empfehlung. Und jetzt kommen natürlich
dann schnell die Fragen, kann man das nicht noch anders machen?
Warum nicht irgendeine Sprache so und so?


[42:57] Und vor allem, warum nicht grafisch darstellen? Könnte
man ja auch. Da gehen wir jetzt nochmal kurz auf ein. Und zwar
war es bis zu dem neuen Prüfungskatalog 2025 gängig, dass die
Pseudocode-Aufgaben auch mit einem Struktogramm oder einem
Programmablaufplan hätten dargestellt werden können. Man hätte
also nicht programmieren müssen, man hätte auch einfach ein
Struktogramm zeichnen können. Gut, dass den Prüfungserstellern
und Erstellerinnen jetzt aufgefallen ist, dass das vielleicht
keiner mehr macht in der Realität und deswegen haben sie das
jetzt gestrichen. Aber eine alternative Darstellung gibt es
natürlich trotzdem. Und das wäre jetzt das
UML-Aktivitätsdiagramm, weil das ja genau dafür da ist.
Algorithmen oder Arbeitsabläufe in einem Unternehmen, was auch
nichts anderes ist, als ein Schritt-für-Schritt-Prozess zu einem
Ziel. Das ist jetzt der Standardweg, um das visuell darzustellen.
Meine Empfehlung ist aber seit Jahren, inzwischen sogar
Jahrzehnten, glaube ich gleich, und zwar mach es einfach nicht.
Schreib bitte Pseudocode. Aktivitätsdiagramm, Struktogramm,
Programmablaufparln haben eins gemeinsam. Die sind super
umständlich zu zeichnen, sau schwierig zu korrigieren und
deswegen würde ich sie dir einfach für eine schriftliche Prüfung
auf Papier nicht empfehlen. Es ist einfach zu aufwendig. Du hast
sowieso viel zu wenig Zeit normalerweise für diese Aufgabe hier.
Wenn du es mal durchrechnest, meistens, zumindest für die
Anwendungsentwickler in Teil 2, sind die Pseudocode-Aufgaben eine
dicke Aufgabe. Also ein Pseudocode für 25 Punkte oder sowas.


[44:15] Dann kannst du dir grob ausrechnen, 90 Minuten
Prüfungszeit geteilt durch deine Punkte, dass du ganz grob
ungefähr pro Punkt der Aufgabe eine Minute Zeit hast in der
Prüfung, um sowas hinzuschreiben. Das heißt, für so eine
Pseudocode-Aufgabe hast du so knapp 25 Minuten, um den kompletten
Text zu lesen und dann auch noch die Aufgabe hinzuschreiben und
zu lösen. Und das wird extrem schwierig, wenn du dann noch am
besten mit dem Lineal irgendwelche Diagramme aufzeichnen musst.
Und was viel schlimmer ist, wenn du die dann korrigieren musst,
weil du siehst, oh, ich habe mich hier einfach vertan. Und sind
wir ganz ehrlich, das passiert vielen in der Prüfung. Sind
aufgeregt, überlesen was, gucken nochmal drüber und stellen fest,
oh, scheiße, letzten Satz habe ich nicht gelesen und so weiter.
Das kommt so oft vor. Also nutzt doch bitte eine
Darstellungsform, die du leicht korrigieren kannst. Und das ist
bei Pseudocor so. Da machst du einfach an der Stelle, wo du das
vergessen hast, ein Sternchen, schreibst ganz unten auf der Seite
nochmal ein Sternchen und schreibst die Zeit, die du vergessen
hast und bist fertig. Beim Aktivitäts-Zirgramm musst du
vielleicht Pfeile durchstreichen, irgendwo noch was daneben
malen, dann passt das. Nicht mehr aufs Blatt, dann machst du da
ein Sternchen hin, dann rafft das aber keiner mehr und so. Also
das ist einfach super schwierig, grafische Darstellungen auf
Papier zu korrigieren. Das ist einfach meine Erfahrung. Deswegen
bleibt meine Empfehlung. Mach es einfach nicht, sondern mach
Pseudocode.


[45:30] So, und dann nochmal, wir hatten es eben schon, warum
benutzen wir nicht in der Prüfung eine genaue Programmiersprache,
zum Beispiel Java? Habe ich jetzt auch schon mehrfach gesagt,
weil nicht jeder IT-Jazubi in Deutschland eine Sprache lernt.
Deswegen brauchen wir was Allgemeines und das ist der Pseudocode.
Also, die einzige echte Alternative wäre das
Aktivitäts-Tilagramm, weil das ist Programmiersprachenunabhängig.
Aber wie gerade erklärt, dauert das zu lange, das zu zeichnen.
Deswegen würde ich es dir nicht empfehlen. Also, aus meiner Sicht
gibt es keine Alternativen zu Pseudocode. Und auch, sehe ich
zumindest so, fände ich es sehr unglücklich, wenn die solche
Aufgaben in Zukunft nicht mehr machen würden, weil die halt den
Kern unseres Berufes abbilden sollen, nämlich algorithmisches
Denken.


[46:06] Also gehen wir mal davon aus, dass die noch ein paar
Jährchen in der Prüfung bleiben, auch wenn wir KI einsetzen, weil
wie gerade schon gesagt, am Ende kann man natürlich die KI in den
Algorithmus vielleicht formulieren, wenn sie die Problemstellung
versteht. Aber da zumindest sind wir Stand 2025 der KI noch
überlegen, was die Problemlösung angeht. Also Probleme, für die
es bislang noch keine Lösung gab, eine Lösung zu finden. Auch ja,
ich weiß, man kann ERK-Prüfungen bei ChatGBT reinstellen, der
löst die dir. Das ist alles ganz toll. Aber es geht darum, dass
du erstmal die Probleme lösen kannst und verstehen kannst und
dann zum Beispiel irgendwann später mal die KI überprüfst, ob sie
das denn richtig gemacht hat. Da muss dann vielleicht doch
nochmal irgendwie ein Mensch drüber gucken. Das heißt, du kommst
einfach nicht drum herum, dieses algorithmische Verständnis
weiterhin dir anzueignen. Das ist zumindest mein Stand im Jahr
2025. Vielleicht gibt es mich in fünf Jahren nicht mehr, weil es
nur noch KI da gibt. Aber naja, wir werden sehen, wie sich das
entwickelt. Bis dahin gehen wir mal


[46:58] davon aus, dass du weiterhin algorithmische Aufgaben in
der Prüfung haben wirst. Und dann ist die Frage, wie bereitest du
dich darauf vor?


[47:04] Weil gerade für die Anwendungsentwickler gibt es halt
viele, viele Punkte für diese Aufgaben. Und für die
Systemintegratorin übrigens auch, habe ich gesehen, gibt es
durchaus auch einen dicken Batzen für so ein Skript, was man da
programmieren muss. Und da ist mein ehrlich gemeinter Tipp,
lernen einfach programmieren. Das hört sich jetzt fies an, aber
wenn Leute mir eine Woche vor der Prüfung eine Mail schicken, ich
kann diese Pseudocode-Aufgaben nicht lösen, was kann ich tun?
Dann kann ich sagen, schwierig. Weil wenn du nicht programmieren
kannst, weil Darum geht es. Ein Problem in Teilprobleme zu
zerlegen und dann diese Probleme zu lösen. Das ist das, was wir
beim Programmieren täglich machen. Dann liegt das nicht am
Pseudocode, den du schreiben musst, sondern liegt das einfach am
Verständnis, wie man solche Probleme löst. Und das ist aus meiner
Sicht etwas, was du in der Ausbildung lernen musst. Und zwar
nicht eine Woche vor der Prüfung, sondern eigentlich ab Tag 1,
weil das ist der Kern des Berufs, Probleme zu lösen.


[47:54] Deswegen mache ich auch diesen Podcast in der Hoffnung,
dass du es nicht eine Woche vor der Prüfung hörst, sondern
rechtzeitig vorher, damit du genau das


[47:58] dir noch aneignen kannst. Das heißt, übe einfach
programmieren. Es gibt so viele Websites online, ob es jetzt, wie
heißen die Dinger, Hacker, Rank oder Code, Schlagmichtor, also
ich weiß es gar nicht. Ich denke mir die Aufgaben immer selber
aus meistens, aber es gibt halt viele, viele Websites, die sich
genau darauf spezialisiert haben. Beispiel-Programmieraufgaben,
kleine mathematische Probleme. Ich kenne zum Beispiel das Project
Euler, finde ich richtig gut. Das geht so mit ganz super
einfachen mathematischen Sachen los, die man programmiert und es
wird immer schwieriger. Man muss immer mehr oder größere Probleme
da lösen. Da habe ich zum Beispiel ein paar Aufgaben von
durchgemacht, das fand ich sehr, sehr spannend. Und es gibt noch
viele, viele weitere Sachen. Es gibt sogar kleine Spiele, mit
denen du das lösen kannst. Zum Beispiel Human Resource Machine
habe ich zum Beispiel ein paar Level durchgespielt, fand ich ganz
cool. Da steuert man so eine kleine Person, die dann im Prinzip
in Assembler programmiert wird, was sie machen soll. Also nimm
die Zahl vom Boden, pack sie in diese Liste und solche Sachen.
Also das ist auch ganz cool, kann man auch machen.


[48:52] Wichtig ist, aus meiner Sicht, üben, üben, üben, machen,
machen, machen. Konkrete Probleme lösen und im besten Fall
kriegst du dann zu deiner Lösung auch Feedback. Dafür sind ja
eigentlich Ausbilder und Ausbilderinnen da, ne? Dass du dann was
programmierst und dann sagen die dir hier, das und das hättest du
anders machen können, besser machen können und so weiter. Und ich
weiß leider auch, dass es viele Azubis gibt, die nicht so
intensiv betreut werden, das kannst du dann ersatzweise eine KI
machen lassen im Jahr 2025. Gib doch den Code irgendwo rein,
irgendein Modell, ich will keines bevorzugen und frag einfach,
was kann ich hier besser machen? Ist das so richtig? Habe ich was
übersehen? Kann ich das noch optimieren, verbessern, verschönern,
was auch immer? Da hat die KI heute ja echt einen Riesen-Benefit.
Die kann dir quasi zumindest, was das Feedback zu deinem Code
angeht, Ausbilder und Ausbilderinnen ersetzen in
Anführungszeichen. Du kannst ja sogar mit der drüber chatten
sowieso, aber auch sprechen. Du kannst dir das Ganze sogar noch
auf dem Audio-Kanal erklären,


[49:43] was du da falsch gemacht hast. Also unbedingt Feedback
einholen, um dich zu verbessern. Darum geht’s, ja? Und dann ist
das grundlegende Vorgehen eigentlich wie immer bei der
Programmierung das Divide and Conquer.


[49:54] Zerlege das Problem in Teilprobleme, solange bis du das
einzelne Teilproblem mit einer Zeile Code lösen kannst. Ganz blöd
gesagt, ja? und das muss man einfach immer wieder machen,
durchspielen mit verschiedenen Problemen, weil du normalerweise
nicht dich auf alle Probleme der Prüfung vorbereiten kannst und
irgendeins davon kommt dann dran, sondern die Aufgabenersteller
denken sich natürlich neue Probleme aus, weil genau darum soll es
ja gehen. Es will in der Prüfung normalerweise keiner von dir
wissen, wie funktioniert der Bubble Sort. Programmieren Sie genau
den Bubble Sort mit dieser Datenstruktur hier.


[50:27] Sondern es geht darum, ich möchte diese Liste sortieren.
Go. Das heißt, es gibt keine genaue Vorgabe, wie etwas zu tun
hat, sondern nur was gemacht werden soll. Und das sollst du dann
zeigen, dass du dieses Problem lösen kannst. Und dafür gibt es
halt nicht eine Liste von 38 Algorithmen, die du auswendig lernen
kannst. Und eine davon kommt dann in der Prüfung dran. Sondern es
ist halt immer eine Mischung, um ein Echtweltbeispiel in der
Prüfung lösen zu können. Um das, was du im Alltag ja auch jeden
Tag machst, zeigen zu können. Es wird niemand, wahrscheinlich,
wird dein Chef oder deine Chefin nie zu dir kommen und sagen, ich
brauche unbedingt einen Bubble Sort. Sondern er wird mit einem
Geschäftsproblem zu dir kommen, sowas wie, keine Ahnung, wir
haben hier einen Stapel Rechnungen von unseren Kunden und das
Finanzamt will die nach Rechnungsnummer sortiert haben. Mach das
mal. So, und dann ist das die Aufgabe. Und dann musst du sagen,
ach, dann nehme ich einen Sortieralgorithmus, und zwar den, den
ich da zufällig gerade kenne oder den ich mir selber ausgedacht
habe oder einen von den 23, die es gibt und programmiere das
dann. Oder ich nehme einfach eine Bibliotheksfunktion, die es
sortiert. Deinem Chef ist es egal, wie du es löst. Hauptsache, du
löst das Problem, dass die Rechnungen nach Rechnungsnummer
sortiert werden.


[51:28] Das soll zu zeigen. Und auf dem Niveau bewegen wir uns
auch in der IRK-Prüfung. Es kann sein, dass wirklich solche
Sachen wie Grundalgorithmen, nenne ich sie mal, in der Prüfung
drankommen. Und das ist sogar sehr häufig so. Also irgendwas
sortieren, irgendetwas suchen, irgendetwas rausfiltern aus einer
Liste zum Beispiel.


[51:45] Solche Basic-Algorithmen können natürlich als Teil so
einer großen Aufgabe mal drankommen. Da steht dann halt in so
einem Halbsatz, ach übrigens, das Endergebnis soll nach
Preisabsteigen sortiert sein oder so. Und das macht dann bei dir
im Kopf hoffentlich Klick. Oh, an der Stelle muss ich einen
Sortieralgorithmus programmieren. Und dann hast du hoffentlich
einen parat, im einfachsten Fall den Bubble-Zort, und
programmierst den eben in fünf Zeilen runter. Und dann ist die
Aufgabe ja gelöst.


[52:11] So, und dieses Divide and Conquer, das mache ich mit
meinen Azubis, wie gesagt, teilweise schon vor der Ausbildung, um
zu gucken, ob das überhaupt was für die ist, mit diesem
Altersbeispiel. Wie berechnest du dein Alter? Und da findet man
schon schnell raus, ob Leute das beherrschen oder nicht. Weil,
jetzt mal kurz gespoilert, wie macht man das? Man zieht erst mal
das heutige, man zieht das Geburtsjahr vom heutigen Jahr ab. Ja,
da habe ich erst mal schon das grobe Alter. Und das Alter kann
jetzt noch um eins abweichen. Wenn ich in diesem Jahr nämlich
noch nicht Geburtstag hatte, dann muss ich davon noch eins
abziehen und ansonsten bleibt es dabei. Und wann hatte ich noch
nicht Geburtstag? Naja, entweder, wenn mein Geburtsmonat in der
Zukunft liegt oder wenn ich im Geburtsmonat bin, aber der Tag
noch in der Zukunft liegt. Und das muss ich jetzt der Reihe nach
abprüfen, um zu dem Ergebnis zu kommen. Und das kriegen viele
einfach nicht so einfach hin. Und daran kann man schon gut, wie
ich finde, nachvollziehen, ob jemand so ein bisschen dieses
Verständnis hat.


[53:01] Und das kann man üben. Ich sage das dann immer ganz gern
so. Versucht das doch mal einem Grundschüler, einer
Grundschülerin zu erklären, die gerade Mathe gelernt hat. Also
rechnen kann die oder er. Und jetzt sag mal, was genau diese
Schülerin da rechnen soll, um das Alter auszurechnen. Und dann
nimmst du das aktuelle Jahr minus das Geburtsjahr. Und das ist
erst mal das vermeintliche Alter. Jetzt muss ich prüfen. Wenn der
Geburtsmonat größer als der heutige Monat ist, dann ziehst du von
dem Alter einen ab.


[53:31] Ansonsten, wenn der Geburtsmonat gleich dem heutigen
Monat ist, dann prüf bitte noch, ob der Geburtstag nach dem
heutigen Tag ist, weil dann musst du auch einen abziehen. Und
wenn das alles nicht zutrifft, geben wir das Alter so zurück. Das
war’s. Ungefähr so müsste der aussehen. Also ein bisschen if und
dann hat man das schon. Aber um da erstmal hinzukommen, tun sich
halt relativ viele Leute dabei schwer und da hilft es mir immer
zu sagen, tu mal so, als wäre ich ein Grundschüler und erklär mir
das mal, was ich jetzt der Reihe nach machen muss. Und wenn dann
sowas steht, wie wenn dann zum Beispiel die Person sagt, ja,
rechne doch einfach den Unterschied zwischen den Datumsangaben
aus. Dann frage ich immer zurück, wie so ein dummer Computer, der
das nicht kompilieren kann. Ja, wie berechne ich denn den
Unterschied zwischen das bei Datumsangaben? Ich kann nur Zahlen
voneinander subtrahieren, aber keine Datumsangaben. Und dann
kommt, ach ja, man muss ja erstmal das Ja abziehen. Okay, das
mache ich. Und dann tue ich so, ja, was soll ich jetzt tun? Ich
habe jetzt das Ja subtrahiert, jetzt gebe ich dir zurück 43. Ja,
aber nee, ist ja nicht richtig, weil du musst ja noch was prüfen.
Ja, dann musst du mir das auch sagen. Ja, okay, dann mach
folgendes. Nimm den Monat und zieh den anderen Monat ab. Und so
mache ich das in so einem Gespräch, um zu erklären, wie es
funktionieren würde. Und so kannst du es dir auch für die Prüfung
mitnehmen. Also, was müsste ich der Reihe nach wie tun, um dieses
Problem zu lösen? Darum geht es.


[54:48] So, das wäre jetzt so meine Empfehlung fürs Lernen. Und
jetzt nochmal kurz, wenn du mit alten Prüfungen lernst, was ich
dir dringend empfehlen würde, weil nur so kriegst du natürlich
auch ein bisschen ein Händchen dafür, für diese Formulierung von
Problemen, für den Umfang der Probleme, dass du es auch zeitlich
ein bisschen besser bewerten kannst, ob du es lösen könntest. Und
dann ganz wichtiger Tipp, wenn du dir diese Lösungsempfehlungen,
Musterlösungen anguckst, dann sei bitte nicht traurig, wenn dein
Code nicht exakt so aussieht wie die Musterlösung. Das ist
nämlich in ganz vielen Fällen so, weil es ist halt eben nur ein
Lösungsvorschlag und eben nicht die Musterlösung, die man exakt
so nachprogrammieren muss, was übrigens für alle anderen Aufgaben
auch gilt, sondern es sind nur Lösungshinweise, die man auch,
glaube ich, aus genau diesem Grund nicht kaufen kann, weil sonst
würden alle sagen, aber ich habe das doch so und so und nicht. Es
ist nur ein Vorschlag und diese Prüfung wird von Menschen
korrigiert und die müssen die Kompetenz haben, das zu bewerten,
ob das richtig ist oder nicht. Und wenn du statt einer
Vorschleife eine While-Schleife benutzt hast und ich als
Prüfender aber sehe, dass das richtig ist, dann gebe ich dir
natürlich die Punkte, auch wenn in der Lösungsvorschlagsaufgabe,
Lösung, so, eine Vorschleife steht. Oder what, was hatte ich
jetzt? Weiß ich nicht. Auf jeden Fall, natürlich gibt es
verschiedene Möglichkeiten, um solche Probleme zu lösen. Es gibt
nicht die eine Lösung. Beispiel Quersumme, die String-Geschichte
oder die Modulo-Geschichte führt beides zum richtigen Ergebnis.
Also kann nicht das eine richtig und das andere falsch sein. Das
ist nicht der Fall. Wenn es funktioniert, wird es auch punktet.
Überhaupt kein Problem.


[56:15] Jetzt kann es aber ja sein, dass du bei deinen Übungen
etwas ganz anders löst, als es halt im Vorschlag steht. Dann ist
natürlich blöd, weil dann kannst du dich ja selber gar nicht
bewerten, ob es jetzt einen Punkt gegeben hätte. Und auch hier
wieder der Hinweis, dafür wäre jetzt vielleicht ein Ausbilder
oder eine Ausbilderin ganz cool, die da vielleicht die Erfahrung
mitbringt und dann wie ein Prüfender das halt bewerten könnte.
Würde hier an der Stelle auch eine Wildschleife statt einer
Vorschleife funktionieren? Ja oder nein? Wenn du das nicht selber
herausbekommen kannst, weil du das vielleicht noch nicht so oft
gemacht hast, dann brauchst du Feedback. Also frag Ausbilder,
Ausbilderin und wenn das nicht geht, nimm die KI. Ich habe es
eben schon gesagt.


[56:50] Dieser Algorithmus ist die Lösung. Ich habe das hier
programmiert. Würde das auch funktionieren? Oder wie auch immer
du die KI danach fragen wolltest. Die wird dir dann bestimmt eine
schöne Lösung dafür geben. So, also wie lerne ich jetzt
Pseudocode-Aufgaben? Mit alten Prüfungen. Gehe die Übungen durch
und versuche runterzubrechen, die weit entkonker. Nimm eine
Programmiersprache, die du kennst, lass alles Überflüssige weg
und am Ende hol dir bitte noch Feedback ein von irgendwem, einem
Menschen oder einer KI, der oder die dir dann sagt, war richtig
oder nicht oder was hast du falsch gemacht, was hast du vergessen
etc. Etc. So. Und dann häufige Fehler.


[57:28] Letzter Punkt für heute. Ich habe auch schon mal ein paar
Pseudocode-Aufgaben korrigiert. Auch wenn ich, ich bin ganz
ehrlich, auch die Prüfenden wollen sich ja wie alle ITler und
ITlerinnen das Leben einfach machen. Und ich habe gar keinen Bock
auf Pseudocode-Aufgaben. Und zwar aus genau dem Grund eben. Denn
man kann das halt auf 27 verschiedene Varianten lösen. Und ich
muss, wenn ich die korrigiere, ja jede dieser Varianten im Kopf
immer durchspielen, ob das funktioniert. Und ob das auch wirklich
funktioniert. Oder ob in diesem einen Edge-Case vielleicht doch
nicht funktioniert. und da muss ich dafür vielleicht einen Punkt
abziehen oder auch nicht. Und das ist extrem aufwendig,
zeitaufwendig und schwierig und gedanklich herausfordernd, diese
Sachen zu korrigieren. Das heißt, das ist, wenn ich irgendwie die
Wahl habe, nehme ich nicht die Pseudocode-Aufgaben zum
Korrigieren, weil das halt mega anstrengend ist. Genauso wie es
für dich schwierig ist, zu schreiben, ist es für die Prüfenden


[58:12] schwierig, die zu korrigieren. Das heißt, nicht meine
Favorite-Aufgaben in der Prüfung, nicht nur die Prüflinge sehen
das so, auch die Prüfenden. Ja, aber wenn wir uns jetzt mal so
ein paar oder wenn ich mir mal so ein paar alte Sachen vorstelle,
die ich mal korrigiert habe, was waren so die Fehler, die ich am
häufigsten gesehen habe? Und da fangen wir an mit meinem
Standardfehler, den du eigentlich bei jeder Aufgabe machen kannst
und zwar nichts hinschreiben. Bei meinen Episoden oder
Blockartikeln, ich weiß schon nicht mehr zu SQL-Aufgaben in der
Prüfung, sage ich das auch immer wieder.


[58:38] Du darfst das Blatt nicht leer lassen. Wenigstens bei
einer SQL-Abfrage könntest du Select, Spalten, From, Tabelle
hinschreiben. Das wäre das absolute Minimum. Dafür musst du
überhaupt nicht verstanden haben, was du in der Aufgabe
eigentlich machen musst. Aber die Spalten und die Tabellen aus
dem Bild abschreiben, das dürftest du immerhin bekommen. Und das
Gleiche gilt beim Pseudocode. Irgendeinen Teil des Pseudocodes
wirst du hinschreiben können. Irgendwo erkennst du vielleicht ein
If oder eine Schleife. Und wenn es auch nur eine Ausgabe am Ende
ist, bei der Quersumme zum Beispiel, gib die Quersumme zurück,
ist dann ein Teil der Aufgabe, dann kannst du wenigstens
hinschreiben, Return Quersumme. Auch wenn du davor überhaupt
nichts berechnet hast, aber zumindest einen Teil des Algorithmus,
nämlich die Rückgabe, die wirst du hinschreiben können.


[59:20] Und das wird dir bei jeder Aufgabe so gehen, egal wie
schwierig die ist oder nicht. Es wird immer irgendwas geben, was
du da hinschreiben kannst. Und wenn es die kleinste Fitzeligkeit
ist, ganz egal, aber es ist alles besser, als das Blatt leer zu
lassen. Aber wenn das Blatt leer ist, dann kann ich dir wirklich,
im wahrsten Sinne des Wortes, nur null Punkte geben. Ich kann da
nichts mehr herzaubern, wo ich sage, ach, in Ansätzen war ja was
da. Nee, leeres Blatt heißt null Punkte. Da gibt es auch keine
Diskussion. Das finde ich super für Prüfende, weil das ist mega
einfach zu korrigieren. Null dran schreiben, next. Aber das ist
für dich natürlich ein Problem, weil du willst natürlich so viele
Punkte wie möglich bekommen.


[59:58] Ja, da kann ich nur empfehlen, schreib irgendetwas hin,
was irgendwie mit der Aufgabe zu tun hat. Und wenn bei Divide and
Conquer du nicht weiterkommst als zur ersten Ebene, dann schreib
wenigstens das hin. Schreib einen Pseudo-Algorithmus super
abstrakter Form hin, wie zum Beispiel bei der Quersumme von
vorhin. Für jede Ziffer der Zahl addiere Zahl auf Quersumme, gib
Quersumme zurück. So, du hast dann das Problem, wie komme ich an
die Ziffern der Zahlen nicht gelöst. Okay, aber du hast erkannt,
dass du die Ziffern durchlaufen musst. Du hast, das habe ich
jetzt gerade vergessen, die Variable Quersumme definiert und die
am Ende zurückgegeben. So, das heißt, keine Ahnung, angenommen es
gäbe jetzt irgendwie 6, 7 Punkte für die Aufgabe, dann könnte ich
dir 3 ja schon mal geben. Weil das Laufen durch die Ziffern hast
du erkannt, du hast was zurückgegeben, du hast was aufsummiert.
Das sind doch Bestandteile, die erstmal funktionieren. Und wenn
du dann einen Teil des Algorithmus nicht perfekt ausformuliert
hast, dann ziehe ich dir dafür Punkte ab, aber es ist doch alles
besser, als null Punkte zu kriegen, weil da gar nichts steht. Ja,
also bitte immer etwas hinschreiben. Das behaupte ich einfach,
dass du das immer machen kannst.


[1:01:01] So, Problem Nummer zwei. Das ist dann sehr häufig der
Fall, dass die Leute einfach die Aufgabenstellung nicht
verstehen. Ja, ich weiß, die IHK-Aufgaben sind immer ein bisschen
besonders, manchmal unnötig kompliziert. Beispiele sind ein
bisschen komisch. Also da kann man sehr lange und häufig drüber
streiten. Ich weiß, das ist blöd und noch schwieriger wird es,
wenn man kein Muttersprachler ist. Ich weiß, das ist ein riesiges
Problem. Nur wir können es leider nicht ändern. Und deswegen ist
meine Empfehlung,


[1:01:29] übe das einfach mit alten Aufgaben. Und wenn du da
irgendwas nicht verstehst, dann wende dich an Ausbilder,
Ausbilderinnen oder KI, die dir ja nicht einfach nur die Lösung
hinklatschen können und sollen, sondern dir das auch erklären
können und sollen, wie man sich da hinarbeitet. Und im Endeffekt
wird es immer die Wide & Conquer sein. Ich glaube nicht, dass
man da viel anders rangehen kann. Aber diese Übung und das
Feedback, das ist das, was dir da weiterhilft. Und deswegen
besorgt dir die alten Prüfungen und macht die Prüfungsaufgaben.
Das ist an der Stelle meine zentrale Empfehlung.


[1:01:59] Und wenn wir dann nochmal runtergehen auf das, was
wirklich in der Programmierung am Ende häufig ein Problem ist,
sind das ganz klassisch Plus-Minus-Eins-Fehler. Da wird dann zum
Beispiel in Schleifen, wie gesagt, in vielen Aufgaben braucht man
wirklich mal eine Vorschleife zum Beispiel, da wird dann halt
einer zu wenig, einer zu viel gezählt, weil statt kleiner gleich
wird kleiner gemacht oder größer oder einfach Vorzeichenfehler
oder sonstige Sachen. Also immer diese klassischen
Programmierfehler, wofür wir auch hoffentlich Unit-Tests
programmieren, die kommen natürlich auch in diesen Algorithmen
dran. Und das ist immer das Erste, wo ich auch hingucke, ob
irgendwas falsch ist, wird richtig gezählt. Beginnt das Array bei
0 oder bei 1? Wo wird her angefangen? Wird zum Beispiel in der
Vorschleife, wenn ich durch ein Array laufe und ich habe eine
Programmiersprache, die 0 basiert ist, was 95% der Sprachen sind,
wenn ich dann bis zu Array.length zähle, dann bin ich natürlich
schon aus dem Array rausgelaufen, weil das letzte Element hat
Array.length minus 1. Und das sind so klassische Fehler, die
natürlich bei Schleifen sowohl in der Realität auftreten können,
als natürlich auch in der Prüfung. Also gerade bei so
Grenzwerten, Array-Länge oder Array-Index und Altersbestimmung
oder sowas, wo es um Grenzwerte geht, größer 18 oder größer
gleich 18, was ist denn jetzt richtig? Diese klassischen
Plus-Minus-Eins-Fehler, unbedingt darauf achten, die werden sehr
häufig falsch gemacht, weil sie halt auch im wahren Leben sehr
häufig falsch gemacht werden. Das ist ja jetzt hier keine
künstliche Situation, sondern diese Probleme sind für Menschen ja
häufig schwierig sofort zu erkennen und das ist in der Prüfung
nichts anderes als im wahren Leben.


[1:03:27] So, dann ein Problem, was ich sehr häufig sehe, was
aber jetzt wirklich prüfungsspezifisch ist und zwar, dass
Aufgaben zu abstrakt gelöst werden. Was meine ich damit? Du löst
die Aufgabe nicht wirklich selbst, sondern du sagst, das macht
der Computer für dich. Mein Beispiel wieder bei der Quersumme.
Durchlaufe die Ziffern der Zahl.


[1:03:45] Das ist etwas, das meines Wissens nach ein Computer
nicht tun kann, weil er das nicht eingebaut hat. Der kann Modulo
und Div und Plus, kann er alles, aber durchlaufe die Ziffern
einer Zahl ist etwas, was er einfach nicht tun kann. Der kennt
diesen Befehl nicht. Das heißt, den musst du weiter
runterbrechen. Und da kannst du dich als Prüfling nicht hinsetzen
und sagen, durchlaufe die Ziffern der Zahlen, summiere alles und
dann löst du einen Algorithmus, der eigentlich sieben Zeilen lang
sein müsste, in zwei. Und hier nehme ich gerne mein Zitat, sei
nicht schlauer als die Prüfenden. Es geht nicht darum zu zeigen,
wie geil du deine Programmiersprache beherrschst. Ich meine das
überhaupt nicht abwertend. In der wahren Welt darfst du das alles
jeden Tag einsetzen und da würde ich das sogar begrüßen und fände
das richtig gut. Aber nicht in der Prüfung. In der Prüfung sollst
du zeigen, dass du die Basics der Algorithmik beherrschst und
dass du weißt, der Computer kann nicht einfach durch Zahlen die
Ziffern iterieren und der Computer kann auch nicht Datum minus
Datum rechnen. Das geht nur mit Int und Double und so weiter. Das
heißt, das ist genau der Punkt, wo du zeigen musst, dass du
weißt, was zu tun ist und dann zum Beispiel eben diese
Modulo-Geschichte oder String umwandeln und so weiter machst. Und
dieses zu abstrakt gelöst, das ist häufig ein Problem. Wir haben
in einigen Aufgaben, hatte ich vorhin schon gesagt, sowas wie,
ach übrigens, die Liste soll noch sortiert werden am Ende. Und
dann schreiben dann halt einige Schlaumeier dahin, als letztes
Statement, list.sort oder array.sort.


[1:05:12] Und das ist genau das, was ich meine. Im Alltag würde
niemand einen Sortieralgorithmus selber programmieren, weil das
ist verschenkte Lebenszeit. Die gibt es halt fertig. Und deswegen
macht man im Alltag natürlich Punktzort und interessiert sich
meistens 0,0 dafür, welcher Algorithmus dahinter steckt. Ich will
einfach nur die Liste sortiert haben. Aber in der Prüfung ist das
halt anders. In der Prüfung sollst du halt zeigen, dass du selber
eine Sortierung programmieren kannst. Und dann reicht es halt
nicht, List.zort zu schreiben, sondern du brauchst halt ein
Minimum irgendeinen ganz kurzen Sortieralgorithmus, und ich sage
jetzt einfach mal so ein Bubblesort, je nachdem, wie prägnant du
den schreiben kannst, sind vielleicht fünf, vielleicht sechs
Zeilen. Du brauchst eine kleine verschachtelte Schleife mit einem
Vergleich und einem Vertausch. Dann sind das vielleicht fünf,
sechs, vielleicht sieben Zeilen. Und es ist halt eben nicht eine
Zeile, List.sort.


[1:05:58] Wäre das in der Realität ein lauffähiges Programm? Ja.
Kriegst du dafür Punkte? Nein. Ja, weil das ist nicht die
Aufgabenstellung. Du sollst nicht mit möglichst wenig Code mit
einer realen Programmiersprache dieses Problem lösen. Das ist
nicht das, was du hier zeigen sollst. Du sollst zeigen, dass du
das Problem selbst lösen kannst und formulieren kannst, wie man
es allgemeingültig lösen kann. Und wenn dazu eine Sortierung
gehört, dann wird von dir erwartet, diese Sortierung selber zu
coden in Pseudocode und nicht zu sagen, hier nimmst du die
Funktion und da nimmst du diese Funktion. Das nehme ich jetzt am
Beispiel sortieren, weil das schön nachvollziehbar ist. Das habe
ich aber an ganz, ganz vielen Stellen in diesen
Sorte-Code-Aufgaben schon gesehen, weil es gibt natürlich in den
Programmiersprachen, die wir heute einsetzen, Bibliotheken ohne
Ende, die alles das, was du in der IHK-Prüfung brauchst,
natürlich für dich machen mit einer Zeile-Code.


[1:06:48] Angenommen, die einzige Aufgabenstellung wäre für
sieben Punkte, sortieren Sie diese Liste. Und du schreibst dann
einfach hin Array.sort. Ich meine, wenn ich das dann sehe als
Prüfling, da muss ich mir doch irgendwie überlegen, kriege ich
wirklich für eine Zeile Code sieben Punkte? Kann das wirklich
sein? Da muss es doch bei mir klingeln und sagen, okay, die
wollen ja doch irgendwie was anderes haben. Das kann doch nicht
sein, dass ich hier eine Zeile Code nur schreiben muss. Das ist
vielleicht nochmal so ein Hinweis, der dir vielleicht auffallen
sollte. Wenn du 25 Punkte für eine Programmieraufgabe kriegst und
du löst die mit drei Zeilen, da kann irgendwas nicht stimmen. Das
wollen wir dann wohl nicht sehen in dieser Aufgabe. Das heißt, in
der Prüfung sollst du die absoluten Basic-Algorithmen sortieren,
suchen, filtern, was auch immer. Die sollst du selber
programmieren und die halt nicht an ein Framework delegieren.
Weil sonst wäre, wenn du das dürftest, wäre ja die Frage, wo
hören wir denn da auf?


[1:07:46] Sortieren, okay, wenn das ein Teilalgorithmus ist, ja,
gut. Aber angenommen, das, was du da programmieren sollst, das
gesamte Problem wäre in deiner Programmiersprache in einer
Bibliotheksfunktion verfügbar. Was weiß ich, jetzt ein anderes
Beispiel zum Sortieren, weiß ich nicht, die Wurzel ziehen oder
sowas aus einer Zahl. Dann kannst du natürlich in Java sowas
machen wie math.squareroot. Und dann bist du fertig. Ja, und das
kann man jetzt natürlich auf alle möglichen Probleme ausweiten.
Wenn jetzt zum Beispiel deine Programmiersprache eine Funktion
hat, um einen Haufen Rechnungen nach Rechnungsnummer zu
sortieren, dann könntest du diesen Algorithmus ja einfach mit
einer Zeile Code in der Prüfung lösen. Aber dann zeigt sich ja
wieder, das funktioniert nur in genau deiner Programmiersprache
mit genau deinem Framework und deiner Bibliothek. Und das ist
wieder etwas, was der Prüfer oder Prüfende nicht nachvollziehen
kann, weil das ja wieder super spezifisch für diese eine Sprache
ist. Und genau das wollen wir ja gerade nicht. Wir wollen ja was
Allgemeingültiges. Ein Algorithmus, den du in jeder beliebigen
Programmiersprache umsetzen könntest und eben nicht spezifische
Python, Java, C Sharp Features dafür brauchst. Das ist der
Hintergrund der Prüfung. Das macht dir bitte immer bewusst. Und
deswegen sage ich, sei nicht schlauer als die Prüfenden. Zeig
nicht, wie geil du deine Programmiersprache kennst. Das ist nicht
gefragt, sondern zeig, dass du das Problem lösen kannst.


[1:09:01] Und anderes Beispiel, wo ich das wirklich schon häufig
gesehen habe, das ist jetzt, das ist nur ein Beispiel und nur
eine Kleinigkeit, aber es gibt Programmiersprachen, wenn ich zum
Beispiel auf das letzte Element einer Liste oder eines Arrays
zugreifen möchte, ja, dann kann ich sowas machen wie Array,
eckige Klammer auf, minus 1, eckige Klammer zu. Also der Index
minus 1 steht dann für das letzte Element des Arrays. In Java zum
Beispiel geht das nicht. Da wäre Array minus 1 ein Fehler, weil
minus 1 ist kein gültiger Index. Fängt bei 0 an, hört bei Länge
minus 1 auf. Geht nicht. Aber es gibt halt Sprachen, die das
anbieten. Und es gibt sogar recht viele Sprachen. Ich weiß es
nicht auswendig, aber ich glaube Ruby, Python, JavaScript, da
kann man es überall machen mit der minus 1. Bitte nicht darauf
festnageln. So, und da sind wir jetzt bei einem Problem, weil das
ist halt ein Feature, was es in vielen Sprachen gibt, aber eben
nicht in allen. Und das erleichtert mir das Leben natürlich
ungemein, weil ich kann einfach sagen Array minus 1 statt Array,
Klammer auf, Array-Length minus 1. Ja, da muss ich halt weniger
schreiben. Da machst du dir das Leben einfacher. Okay. Aber
andersherum, wenn ich so eine Programmiersprache noch nie gesehen
habe und zum Beispiel nur mit Java arbeite und überhaupt nicht
weiß, dass es so etwas gibt.


[1:10:08] Gut, dann kann man sich fragen, müssten die Prüfer und
Prüferinnen das nicht wissen? Ja, bla bla bla, andere
Diskussionen. Aber wenn ich es nicht weiß und ich kann einfach
nicht alles wissen, ganz ehrlich, ja, ich kann nicht alle
Features aller Programmiersprachen der Welt kennen, um dann
bewerten zu können, ob du es richtig gemacht hast. Das heißt,
wenn du so ein kleines Feature benutzen möchtest, frage bitte
dich selber dreimal, versteht jemand anders das auch, der
vielleicht nicht seit drei Jahren mit meiner Programmiersprache
arbeitet? Und da gehören so Kleinigkeiten wie letztes Element des
Arrays dazu. Und wenn du keinen Bock hast, das mit Array in
Klammern Array Länge minus 1 zu machen, dann schreib doch einfach
hin, x gleich letztes Element des Arrays. Das wäre gültiger
Observer Code. Ja, es ist nicht notwendig, dass du das mit einer
Programmiersprachenähnlichen Syntax machst, sondern du kannst
einfach sagen, ich will hier das letzte Element des Arrays haben.
Punkt. So, das versteht jeder Prüfende. Dafür brauchst du keine
speziellen Python-Kennnisse oder sonst irgendwas. Ja, und das
wird auch in Java funktionieren, weil letztes Element des Arrays
abfragen, da würde ich dann als Java-Entwickler halt wissen, wie
ich das mache und programmiere das halt schnell. Aber das Array
in Klammern minus 1, da wüsste ich im Zweifel noch nicht mal, was
du überhaupt von mir willst. Und das ist ein Problem, ja? Also
sei nicht schlauer als die Prüfenden. Wie soll ich sagen?
Delegiere deine eigentliche Programmieraufgabe nicht an


[1:11:23] Bibliotheksfunktionen und verwende keine
Schlaumeier-Funktionen in deiner Programmiersprache. Das wäre so
kernzusammengefasst meine Empfehlung.


[1:11:32] Genau das Gleiche gilt halt für moderne
Programmierwerkzeuge, wie zum Beispiel in Java die Streams oder
Link in C-Sharp, hatte ich auch schon mal original die Frage,
könnte ich diese Aufgabe hier in der JAK-Führung nicht auch mit
einem Link-Statement lösen? Ja, könntest du. Gib dir aber keine
Punkte. Weil du sollst ja den Algorithmus formulieren, imperativ,
Sequenz, Verzweigung, Wiederholung. Und Streams und Link und ich
weiß nicht, wie es in anderen Problemen heißt, also wenn ich
diese quasi Art der funktionalen Programmierung habe. Ich kann
zum Beispiel listen, filtern und mappen und reducen und so dieses
Prinzip. Was in vielen Sprachen inzwischen funktioniert. Aber das
ist ja eher eine deklarative Sprache.


[1:12:13] Und das ist ja auch cool, weil ich muss dann ja gar
nicht wissen, wie das funktioniert. Und allein schon bei dieser
Erklärung sollte dir klar werden, okay, ich muss gar nicht
wissen, wie der Stream die Liste filtert, aber ich bin gerade in
einer IHK-Prüfung, wo ich genau das zeigen soll, nämlich wie man
eine Liste filtert. Dann musst du doch eigentlich auch hier
irgendwo es klick machen und sagen, okay, das können die nicht
von mir jetzt sehen wollen. Das heißt, wenn da sowas steht wie,
sortier aus dieser Liste an Personen nur die männlichen raus,
dann kann das nicht eine Zeile Code sein, Punkt Filter, where,
Geschlecht gleich M oder so. Das wäre also der deklarative, in
Anführungszeichen, wie ein SQL-Ansatz. Da musst du auch nicht
wissen, wie die Datenbank das macht. Das macht SQL für dich. Aber
hier geht es ja genau darum, zu zeigen, wie die Datenbank es
machen würde, wenn du die Datenbank programmieren müsstest. Da
kannst du nicht sagen, where, irgendwas, sondern musst du die
gute alte Schleife rausholen, du musst die Elemente durchlaufen,
du musst das Geschlecht vergleichen. Wenn ja, packst du es in die
Liste, ansonsten nicht, und dann gibst du die Liste zurück. Und
das ist der Algorithmus, den wir da sehen wollen.


[1:13:13] Also, nicht abstrakt, nicht deklarativ, keine
programmierspezifischen Sachen, sondern einfach nur die Basic
Sequenz Verzweigung Wiederholung. Das benutzt du in den Aufgaben.
Und dann holst du auch das Maximum der Punkte, im besten Fall
alle. So, der letzte Punkt, das habe ich jetzt nicht so häufig
gesehen, aber das wurde ich auch schon ein paar Mal gefragt. Muss
ich hier die perfekt optimierte, performance-optimierte Lösung
abgeben? Antwort nein. Warum kam die Frage? Gleiche Aufgabe, die
Liste sollte am Ende sortiert werden. Muss ich da jetzt einen
QuickSort implementieren? Weil der ist ja viel schneller als ein
BubbleSort. Und dann sage ich, sowohl für die Prüfung als auch
für die Praxis, Nein, das musst du nicht. Das interessiert kein
Mensch, in welchen Sortiergruppen es du da benutzt. Das ist ein
Problem, was nur dann ein Problem ist, wenn es sich als Problem
in der Realität äußert. Was heißt das?


[1:14:03] Wenn du eine Liste sortierst und in einem Webbrowser
ausgeben willst über eine Web-Anwendung und es tatsächlich einen
Unterschied macht in der Response-Time deiner Anwendung, ob du
ein Quick-Sort oder ein Bubble-Sort nutzt, dann wird das ein
Problem für dich.


[1:14:19] In 99,9999999% deiner Poemier-Aufgaben wird das
wahrscheinlich niemals ein Problem sein. Du könntest den
Sortier-Algorithmus rauf und runter optimieren und ersetzen und
hier noch eine Vorschleife kürzen und dies und das kannst du
alles machen. Und am Ende hast du dann 3 Millisekunden Laufzeit
rausgeholt, weil du deine Vorschleife perfekt optimiert hast. Und
dann wird aber das Ergebnis deiner Sortierung über einen schönen
REST-Aufruf in den Browser per HTTP übertragen und dann nochmal
von JavaScript rausgerendert und mit CSS versehen und bla. Und
der ganze Aufruf dauert 10 Sekunden. Aber in deiner Vorschleife
hast du 10 Millisekunden eingespart. Herzlichen Glückwunsch. Das
nennt man Premature Optimization. Das heißt, du fängst an, deinen
Code zu optimieren, obwohl es noch nicht mal ein Problem gibt.
Und da kann man als Entwickler Stunden und Tage mit verschwenden,
ein Problem zu lösen, was es nicht gibt, nämlich einen zu
langsamen Sortieralgorithmus zu optimieren. Und ich behaupte
einfach, für diese Anwendung, die wir üblicherweise in der
Prüfung und auch in der Praxis, für den Großteil der Zuhörenden
hier wird das sicherlich gelten, ist es völlig irrelevant, ob du
ein Bubble, einen Quick, einen Insertion oder einen Selection
Sort nutzt. Das wird keinerlei Auswirkung haben, weil wenn
überhaupt, reden wir hier von Unterschieden im
Millisekundenbereich und in den normalen Anwendungen wirst du das
niemals merken, ob es drei oder drei zehn Millisekunden gedauert
hat. Das ist völlig irrelevant.


[1:15:42] Solltest du zu der ganz besonderen Gruppe von Menschen
gehören, die täglich mit drei Milliarden Datensätzen hantieren
und die sortieren müssen, dann darfst du dich gerne mit den Vor-
und Nachteilen der Sortierallgruppen auseinandersetzen. Ansonsten
nimmst du einfach den Bubble Sort und gehst zum nächsten Problem.
Und wenn irgendwann deine Anwender sagen, jetzt betreiben wir
dieses ERP-System seit zehn Jahren und haben drei Millionen
Datensätze in der Datenbank, jetzt wird es ein bisschen langsam.
Dann kannst du dann in zehn Jahren den Sortierallgruppen
optimieren. Aber nicht heute Stunden reinstecken, um
Millisekunden rauszuholen. Das ist nicht nötig. Und vor allem ist
es in der Prüfung nicht nötig. Wie gesagt, hier sollst du nur das
Problem lösen, sortier die Liste. Und hier ist nicht das Problem,
sortier die Liste möglichst schnell, sondern sortier die Liste.
Und wenn du das mit einem Bubble Sort, den du auswendig in 10
Sekunden hinschreiben kannst, ich übertreibe jetzt, lösen kannst,
dann machst du das. Weil dein Ziel in der Prüfung ist ja,
möglichst viele Punkte zu holen und nicht einen Algorithmus auf
Papier zu optimieren, den es sowieso nicht gibt, weil es gerade
eine Prüfung ist. Das heißt, löst das Problem so einfach wie
möglich. Es muss nicht schnell sein, es muss nicht schön sein. Es
muss einfach nur funktionieren.


[1:16:51] Also verschwende keine Zeit in der Prüfung mit
irgendeiner Optimierung, die nicht notwendig ist. Löse einfach
das Problem. Ende.


[1:17:00] So, das war alles, was ich zu Pseudocode-Aufgaben zu
sagen habe heute.


[1:17:07] Wir fassen nochmal zusammen. Pseudocode-Aufgaben sollen
dein algorithmisches Verständnis zeigen. Das heißt, sei nicht
schlauer als die Prüfenden, zerlege das Problem in Teilprobleme,
die du dann irgendwann mal mit einer Zeile Code lösen kannst.
Guck drauf, wenn es 25 Punkte gibt, dass du auch ein paar mehr
Zeilen hast als drei, um auch auf diese Punkte zu kommen. Schreib
immer etwas hin, auch wenn du nicht so Ahnung hast, wie das
Problem an sich löst. Ein Teilproblem wirst du immer lösen
können. Denk dran, dass das von Menschen korrigiert wird, die
verstehen müssen, was du dahingeschrieben hast. Benutze keine
komischen Sprachfeatures, die nur du kennst oder eine ausgewählte
Gruppe an Python-Entwicklerinnen, sondern jeder Mensch, der sich
einigermaßen mit Programmierung auskennt, muss das verstehen
können. Es gibt keinen Standard-Pseudocode. Du kannst
hinschreiben, was du willst. Meine Empfehlung, nimm deine
Lieblingsprogrammiersprache. Lass alles Unnötige drumherum weg,
wie Klammern und so weiter. Achte aber auf saubere Einrückungen,
damit man die Struktur des Codes weiterhin erkennt. Lass alles
coole und abstrakte deiner Sprache weg. Reduzier dich auf
Sequenz, Verzweigung und Wiederholung. Mach es nicht mit einem
Aktivitäts-Zirgramm. Es ist zu aufwendig und schlecht zu
korrigieren. Und wie bereitest du dich vor? Üben, üben, üben. Am
besten mit alten Prüfungsaufgaben oder mit Online-Plattformen, wo
du einfach Algorithmik, kleine Programmieraufgaben, wie zum
Beispiel Project Euler, üben kannst. Und hol dir Feedback ein. Im
besten Fall von einem Menschen, im zweitbesten Fall von einer KI,
die dir sagt, was du besser machen kannst. Und achte auf die
üblichen Fehler. Plus, minus eins.


[1:18:31] Zu abstrakt gelöst. Gar nichts hinschreiben geht gar
nicht. Immer was hinschreiben.


[1:18:35] Das wäre so kurz gesagt nochmal zusammengefasst die
Episode heute.


[1:18:39] Ich hoffe, das hat dir ein bisschen geholfen.
Vielleicht hat es dir auch ein bisschen die Angst vor den
Aufgaben genommen. Aber im Endeffekt steht und fällt das, glaube
ich, alles mit üben, üben, üben. Das heißt, fang nicht erst eine
Woche vor der Prüfung an, die Dinger zu üben, sondern am besten,
ehrlich gesagt, musst du sowas im ersten Ausbildungsjahr schon
anfangen. Damit du bis zur Prüfung genug Zeit hast, das zu
wiederholen, zu vertiefen, verschiedene Probleme auch schon mal
gesehen hast, vielleicht sogar einen Teil wiedererkennst. Ach,
das kann ich so und so machen, das habe ich schon mal gehabt und
so weiter.


[1:19:08] Die kannst du sehr gut bearbeiten mit Erfahrung. Und
dafür musst du es aber auch mal gemacht haben. Also fang früh
genug damit an. Das wäre meine Empfehlung. So, ich hoffe, du
kriegst viele Punkte für die Psorocode-Aufgaben in deinen
Prüfungen. Egal ob AP1, AP2, FISI, FIAE, ganz egal. Sind alle
sehr ähnlich aufgebaut. Und damit wünsche ich dir viel Erfolg für
deine Prüfung. Wenn du Feedback für mich hast, lass es mir gerne
da als Kommentar unter der Episode. Die Shownotes inklusive
Transkription und allem, was dazugehört, findest du natürlich wie
immer unter itberufepodcast.de slash 195.


[1:19:42] Und ja, wenn du es noch nicht gemacht hast, darfst du
gerne meinen Newsletter abonnieren unter itberufepodcast.de slash
Newsletter. Da bekommst du von mir eine Ausbildungsbegleitung
über deine drei Ausbildungsjahre. Gilt übrigens auch für
Ausbilder und Ausbilderinnen. Die kriegen dann auch immer
regelmäßig E-Mails mindestens eine die Woche. Zum Beispiel zur
Prüfungsvorbereitung. Das heißt, da solltest du normalerweise,
zeitnah vor der Prüfung die Info kriegen, hey, hast du dich schon
mal mit Pseudocode beschäftigt, damit du das nicht vergisst. Und
das gibt es über die ganzen drei Jahre ungefähr einmal die Woche.
Ist immer was dabei. Und ja, völlig kostenfrei. Kannst dich auch
jederzeit wieder abmelden, wenn du keine Lust mehr drauf hast.
Kannst dich also gern mal darum bemühen. Ja, und letzter Hinweis.
Pseudocode ist natürlich eine super stark nachgefragte,
Aufgabenvariante bei den Anwendungsentwicklerinnen, weil halt so
schwierig und meistens viele Punkte.


[1:20:28] Und falls du dich damit wirklich noch intensiver
beschäftigen möchtest und nicht noch andere Möglichkeiten hast,
das zu üben, ich habe einen Online-Kurs zur Vorbereitung auf die
AP2 für Anwendungsentwicklerinnen. Den findest du unter.


[1:20:43] Dieperfekteihkprüfung.de Das Üfung, bitte mit UE. Und
da kannst du dich anmelden, wenn du Interesse hast. Da gibt es
Stand heute zur Aufnahme nur ein paar Aufgaben zu Pseudocode,
aber ich werde auch im Laufe der Zeit entsprechende Erklärvideos
zu Pseudocode-Aufgaben dort hinterlegen, damit du es dir damit
auch in Ruhe anschauen kannst. Ja, guck doch mal rein, wenn dich
das interessiert und du die AP2 für Anmeldungsentwickler, ich
sag’s nochmal ganz deutlich, noch vor dir hast. Ein paar andere
Themen haben wir auch schon gemacht. Datenbankmodellierung, SQL
natürlich und Testverfahren, Schreibtischtest, sowas, die sind
auch schon online. Pseudocode wird auf jeden Fall zeitnah
nachgereicht vor der nächsten AP2. Jetzt, wo ich das hier
aufnehme, im Mai 2025 ist sie ja gerade erledigt. Aber ich denke
mal, bis zur nächsten Winterprüfung wird es auf jeden Fall auch
was zum Pseudocode dort geben. Ja, das war der letzte Hinweis und
damit sage ich vielen Dank fürs Zuhören heute. Wir hören uns beim
nächsten Mal und ja, bis denn. Tschüss.