magicmarcy.de

NPS1E6: Look-and-Say Sequence - Zahlenfolgen mit String-Logik erzeugen

Fri, 10 Jul 2026 17:30:00 +0200

In der Serie "Named Problems" stelle ich dir klassische, namentlich bekannte Algorithmus-Probleme vor, die seit Jahrzehnten in Ausbildung, Studium und Interviews verwendet werden. Anhand verständlicher Problemstellungen wie FizzBuzz, Türme von Hanoi oder dem Sieb des Eratosthenes lernst du hier, algorithmisch zu denken, Lösungsstrategien zu entwickeln und diese sauber in Java umzusetzen.

Von while bis for-each: Schleifen in Java praxisnah erklärt

Tue, 07 Jul 2026 17:40:41 +0200

In Java brauchst du Schleifen immer dann, wenn eine Aufgabe nicht nur einmal, sondern mehrfach ausgeführt werden soll. Technisch lösen Schleifen das Problem, dass du denselben Code nicht kopieren und wiederholen musst. Fachlich bedeuten sie meistens: Gehe eine Menge von Dingen durch, warte auf einen Zustand, wiederhole eine Prüfung oder führe eine Aktion so lange aus, bis ein Ziel erreicht ist.

Comparator - die Schlüsselwaffe für Sortierungen

Sun, 05 Jul 2026 17:43:26 +0200

Du hast sicherlich schonmal in Java eine Liste sortiert - vielleicht mit Arrays.sort() oder Collections.sort(). Doch was passiert hinter der Szene, wenn du mehrere Sortierkriterien hast oder die Standardsortierung nicht ausreicht? Das ist genau das, was ein Comparator löst. Ein Comparator ist eine Hilfsklasse in Java, die es dir erlaubt, eine eigene Sortierlogik zu definieren. Ohne ihn wäre es schwierig, komplexe Sortierungen durchzuführen oder mehrere Kriterien gleichzeitig zu berücksichtigen.

NPS1E5: Happy Numbers - Iterationen, Zustände und Abbruchbedingungen

Fri, 03 Jul 2026 17:30:00 +0200

Dein Code ist nicht gut, nur weil er läuft

Wed, 01 Jul 2026 17:51:43 +0200

Es gibt einen Satz, den man am Anfang ständig still mit sich herumträgt: Hauptsache, es funktioniert. Das ist nachvollziehbar. Du willst ein Ergebnis sehen, Fehler wegklicken, eine Ausgabe bekommen und endlich das Gefühl haben, dass du es verstanden hast. Genau an diesem Punkt fangen aber viele schlechte Gewohnheiten an. Denn Code, der gerade so läuft, ist nicht automatisch guter Code. Er kann unklar sein, unnötig kompliziert, schwer testbar oder so fragil, dass schon die nächste kleine Änderung neue Fehler produziert.

Grundlagen und praktische Anwendung von Strings

Mon, 29 Jun 2026 17:40:22 +0200

Strings sind ein grundlegendes Konzept in Java, das du als Anfänger unbedingt verstehen solltest. Sie sind so verbreitet, dass du sie tagtäglich im Code verwendest, oft ohne groß darüber nachzudenken. Doch selbst bei solchen Grundlagen gibt es viele Nuancen und Fallen, auf die du achten musst. In diesem Artikel erkläre ich dir, warum Strings in Java unveränderlich (immutable) sind, was das bedeutet und wie du sie richtig nutzen kannst.

Spring Boot ohne Buzzwords - die Grundlagen einfach erklärt

Sun, 28 Jun 2026 17:46:00 +0200

Spring Boot ist für viele der erste Kontakt mit moderner Java-Backend-Entwicklung. Der Name taucht schnell auf, wenn es um REST-APIs, Webanwendungen oder kleine Services geht. Gleichzeitig wirkt das Thema am Anfang oft größer, als es eigentlich ist. Überall liest du etwas von Starter, Auto Configuration, eingebettetem Server oder Dependency Injection. Wenn du das zum ersten Mal siehst, kann das schnell unnötig kompliziert wirken.

NPS1E4: ROT13 - Eine einfache Verschlüsselung ohne Geheimnisse

Fri, 26 Jun 2026 17:30:00 +0200

Warum Softwarehygiene deinen Java-Alltag leichter macht

Thu, 25 Jun 2026 17:48:00 +0200

Softwarehygiene klingt im ersten Moment etwas sperrig. Gemeint ist damit aber nichts Abgehobenes, sondern ein sehr praktischer Teil deines Entwickleralltags. Es geht darum, deinen Code, dein Projekt und deine Arbeitsweise so sauber zu halten, dass du dich auch morgen noch darin zurechtfindest. Gute Softwarehygiene sorgt dafür, dass ein Projekt lesbar bleibt, Fehler schneller auffallen und kleine Änderungen nicht jedes Mal unnötig anstrengend werden.

Threads, Timing, Chaos: Nebenläufigkeit in Java einfach erklärt

Tue, 23 Jun 2026 17:41:30 +0200

Nebenläufigkeit bedeutet, dass ein Programm mehrere Aufgaben überlappend bearbeiten kann. Das heißt nicht automatisch, dass wirklich alles exakt gleichzeitig passiert. Es bedeutet zuerst einmal nur: Dein Programm wartet nicht stur darauf, dass eine Aufgabe vollständig fertig ist, bevor es mit der nächsten weitermacht.

Java Einstieg: Was am Anfang wirklich zählt

Mon, 22 Jun 2026 17:27:36 +0200

Java wirkt am Anfang oft schwerer, als es eigentlich ist. Nicht, weil die Sprache absichtlich kompliziert wäre, sondern weil sie dich sehr früh mit Dingen konfrontiert, die bei HTML, CSS und auch JavaScript oft später oder weniger sichtbar auftauchen. Du schreibst nicht einfach ein paar Zeilen in eine Datei, öffnest sie im Browser und siehst sofort etwas auf dem Bildschirm. Du arbeitest mit Klassen, Methoden, Typen, einem Compiler, einer Laufzeitumgebung und meistens direkt mit einer IDE wie IntelliJ.

PrimeFaces in Java: Praktischer Baukasten oder versteckte Magie?

Sat, 20 Jun 2026 17:52:54 +0200

PrimeFaces ist eine Komponentenbibliothek für Jakarta Faces, früher meistens unter dem Namen JavaServer Faces oder kurz JSF bekannt. Die ganz kurze Antwort wäre also: PrimeFaces ist ein Framework beziehungsweise eine UI-Bibliothek für Java-Webanwendungen. Diese Antwort ist nicht falsch, aber sie ist zu grob. Sie erklärt nicht, warum PrimeFaces anders funktioniert als viele moderne Frontend-Frameworks und warum man damit in Java-Projekten recht schnell brauchbare Weboberflächen bauen kann.

NPS1E3: Caesar Cipher - Zeichen verschieben und Texte transformieren

Fri, 19 Jun 2026 17:30:00 +0200

Legacy-Code lesen: So findest du den Einstieg

Wed, 17 Jun 2026 17:23:25 +0200

Komplexer Code fühlt sich am Anfang oft an wie eine Wand. Du öffnest eine Klasse, springst in eine Methode und siehst erst einmal sehr viel auf einmal. Viele Bedingungen, verschachtelte Blöcke, alte Namen, Sonderfälle, technische Details und vielleicht noch Kommentare, die entweder fehlen oder seit Jahren nicht mehr stimmen. Gerade bei der Fehleranalyse landet man schnell genau in solchen Methoden. Der Bug sitzt selten in der kleinen, sauberen Beispielklasse. Er sitzt eher in einem Bereich, der schon lange existiert und durch viele Anforderungen gewachsen ist.

Normale Bean oder Session Bean? Der Unterschied verständlich erklärt

Mon, 15 Jun 2026 17:48:45 +0200

Im Java-EE-/Jakarta-EE-Umfeld bezeichnet „Session Bean“ eine serverseitige Komponente, die vom Application Server verwaltet wird. In WildFly bedeutet das ganz konkret: Der Container erstellt Instanzen, steuert deren Lebenszyklus und führt Methodenaufrufe in einem Rahmen aus, der dir Infrastruktur abnimmt. Du schreibst fachliche Logik, der Server liefert dir Dinge wie Transaktionen, Security, kontrollierte Nebenläufigkeit und Dependency Injection.

Java testen mit Mockito: Die Grundlagen ohne unnötigen Ballast

Sun, 14 Jun 2026 17:32:00 +0200

Wenn du mit Java Tests schreibst, stößt du ziemlich schnell auf ein Problem: Deine Klasse arbeitet oft nicht allein. Sie ruft andere Klassen auf, spricht vielleicht mit einer Datenbank, nutzt eine externe API oder verschickt Nachrichten. Genau an der Stelle kommt Mockito ins Spiel.

NPS1E2: Palindrom - Strings vergleichen und Schleifen verstehen

Fri, 12 Jun 2026 17:30:00 +0200

So löst du Bugs mit dem RubberDuck Prinzip

Thu, 11 Jun 2026 17:38:07 +0200

Solche Momente gehören in der Softwareentwicklung ganz automatisch dazu: Du sitzt vor deinem Code, alles sieht auf den ersten Blick okay aus und trotzdem passt das Ergebnis nicht. Das kann frustrierend sein, ist aber völlig normal. Genau für solche Situationen gibt es das RubberDuck Prinzip. Gerade am Anfang hilft es oft besonders spürbar, aber es ist längst keine Technik nur für Einsteiger. Auch erfahrene Entwickler nutzen sie, wenn sie ihre Gedanken sortieren und Fehler sauber eingrenzen wollen.

Dekomposition in Java: Wie du komplexe Aufgaben endlich greifbar machst

Tue, 09 Jun 2026 17:50:27 +0200

Viele Probleme wirken am Anfang größer, als sie eigentlich sind. Gerade in Java passiert das schnell. Du bekommst eine Aufgabe wie "Baue einen Import für CSV-Dateien", "Erstelle einen Login" oder "Berechne den Gesamtpreis eines Warenkorbs mit Rabatten" und merkst sofort: Das ist keine einzelne Methode. Das ist auch keine Klasse, die du in zehn Minuten runterschreibst. Es ist ein Bündel aus mehreren Entscheidungen, mehreren Regeln und mehreren kleinen Baustellen. Genau an dieser Stelle hilft dir ein sauberer Gedankengang. Nicht, weil das Problem dadurch verschwindet, sondern weil es auf einmal greifbar wird.

Nicht nur Code schreiben - so denkst du wie ein Entwickler

Sat, 06 Jun 2026 17:41:53 +0200

Wie ein Entwickler zu denken bedeutet nicht, dass du besonders schlau sein musst oder dass du schon auf jede Frage eine Antwort hast. Es bedeutet vor allem, wie du an Probleme herangehst. Gerade in Java merkst du ziemlich schnell, dass sauberes Denken oft wichtiger ist als das Auswendiglernen von Syntax. Ob du mit einer kleinen Konsolenanwendung arbeitest, eine REST-Schnittstelle in JavaEE baust oder zum ersten Mal mit Maven, Git und IntelliJ klarkommen willst: Am Ende zählt nicht nur, dass etwas irgendwie läuft, sondern dass du verstehst, warum es läuft oder warum es gerade nicht läuft.

NPS1E1: FizzBuzz - Der Einstieg in Bedingungen und Kontrollfluss

Fri, 05 Jun 2026 17:30:00 +0200

In-Memory, H2, SQLite: Was du wirklich wissen musst

Wed, 03 Jun 2026 17:41:28 +0200

Wenn du mit Java anfängst, stolperst du früher oder später über Begriffe wie H2, In-Memory-Datenbank oder SQLite. Auf den ersten Blick klingt das alles ähnlich. Irgendwie geht es um Datenbanken, oft um kleine Projekte, lokale Tests oder einfache Anwendungen. In der Praxis steckt dahinter aber nicht immer dasselbe. Genau das sorgt am Anfang schnell für Verwirrung.

JPA für Einsteiger - endlich verständlich erklärt

Mon, 01 Jun 2026 17:42:38 +0200

JPA steht für Java Persistence API. Allein dieser Name wirkt am Anfang oft größer, als das Thema eigentlich ist. Wenn du ihn einmal sauber auseinanderziehst, wird es deutlich greifbarer. Java ist klar, damit arbeitest du im Code. API bedeutet hier nicht Web-API, sondern eine definierte Programmierschnittstelle, also ein Regelwerk dafür, wie etwas genutzt wird. Und Persistence meint in diesem Zusammenhang, dass Daten dauerhaft gespeichert werden, also nicht nur kurz im Arbeitsspeicher leben, sondern in einer Datenbank abgelegt werden.

Konkurrenz und Threads in Java einfach erklärt

Sat, 30 May 2026 17:45:09 +0200

Wenn du in Java zum ersten Mal über Konkurrenz und Threads stolperst, wirkt das Thema schnell größer, als es eigentlich sein muss. Das liegt vor allem daran, dass mehrere Begriffe durcheinandergeworfen werden. Mal ist von Parallelität die Rede, mal von Nebenläufigkeit, mal einfach nur von Threads. Dazu kommen dann noch Begriffe wie Synchronisierung, Race Condition oder Deadlock. Für den Einstieg reicht es aber, wenn du die Grundlagen sauber auseinanderhalten kannst. Genau darum geht es hier.

Angular, React, Vue und mehr: So ordnest du die Frontend-Begriffe endlich richtig ein

Thu, 28 May 2026 17:56:36 +0200

Wenn du aus der Java-Welt kommst, wirken Begriffe wie JavaScript, TypeScript, Angular, React, Vue, Node.js oder npm am Anfang schnell wie ein einziger großer Themenblock. Genau da entsteht oft die eigentliche Verwirrung. Alles klingt ähnlich, vieles taucht im gleichen Projekt auf, aber nicht alles ist dasselbe. Manche Begriffe beschreiben eine Sprache, andere ein Framework, wieder andere eine Laufzeit oder ein Werkzeug.

Fehlerbehandlung in Java - so unterscheiden sich Checked und Unchecked Exceptions

Tue, 26 May 2026 17:32:00 +0200

Fehler gehören beim Programmieren dazu. Gerade in Java stolperst du ziemlich früh über sie, weil dir der Compiler an vielen Stellen sehr deutlich sagt, dass etwas schiefgehen kann. Dabei tauchen meistens zwei Begriffe auf, die erst einmal unnötig kompliziert wirken: checked exceptions und unchecked exceptions. Der Unterschied ist aber nicht nur Theorie. Er beeinflusst direkt, wie du Methoden schreibst, wie sauber dein Fehlerhandling ist und wie gut andere deinen Code benutzen können.

Regex in Java: wann es hilft und wann du es lassen solltest

Sun, 24 May 2026 17:53:00 +0200

Regex ist für mich so ein Thema, bei dem ich innerlich erstmal bremse. Nicht, weil es grundsätzlich schlecht wäre, sondern weil es sehr leicht ist, etwas hinzuschreiben, das irgendwie funktioniert, aber niemand im Team später noch sauber lesen oder sicher beurteilen kann. Genau das ist das Problem. Ein Regex kann auf den ersten Blick kompakt wirken und trotzdem fachlich danebenliegen oder mehr matchen als gedacht.

Der Moment, in dem du alles infrage stellst - und warum du trotzdem weitermachen solltest

Fri, 22 May 2026 17:49:32 +0200

Es gibt in der Entwicklung einen Moment, der ziemlich weh tun kann. Du sitzt vor deinem Code, liest zum dritten Mal dieselbe Fehlermeldung, klickst dich durch Klassen, Methoden und Konfigurationen und plötzlich ist er da, dieser Gedanke: Ich kann nix. Vielleicht kommt direkt noch mehr dazu. Vielleicht fragst du dich, ob du den falschen Beruf gewählt hast. Ob die anderen viel weiter sind. Ob du irgendwas Grundlegendes nicht verstanden hast.

Warum du mit sauberem Code weiter kommst als mit komplizierten Lösungen

Wed, 20 May 2026 17:53:28 +0200

Am Anfang wirkt komplexer Code oft beeindruckend. Da steckt viel Logik drin, es gibt verschachtelte Bedingungen, generische Konstrukte und Methoden, die scheinbar alles gleichzeitig lösen. Auf den ersten Blick sieht das nach Können aus. In der Praxis ist das aber selten ein Vorteil.

Java Arrays mit mehreren Dimensionen verstehen ohne Kopfschmerzen

Tue, 19 May 2026 17:41:22 +0200

Sobald du in Java nicht mehr nur eine einfache Liste von Werten brauchst, landest du schnell bei Arrays mit mehreren Dimensionen. Genau an der Stelle wird es für viele unübersichtlich. Ein normales Array ist noch leicht zu greifen: mehrere Werte hintereinander in einer Reihe. Ein multidimensionales Array erweitert genau diese Idee. Du hast dann nicht nur eine Reihe, sondern mehrere Reihen, Ebenen oder noch mehr Schichten.

Operatoren in Java und die kleinen Unterschiede, die wichtig sind

Sat, 16 May 2026 17:49:19 +0200

Operatoren sind in Java die Bausteine, mit denen du Werte zuweist, vergleichst, verrechnest oder logisch verknüpfst. Sie wirken oft unscheinbar, entscheiden aber sehr schnell darüber, ob dein Code korrekt läuft oder still und leise etwas anderes macht als gedacht. Gerade am Anfang sehen viele Operatoren ähnlich aus, verhalten sich aber im Detail unterschiedlich. Genau diese kleinen Unterschiede sind wichtig.

Maven Profile einfach erklärt - so steuerst du deinen Build gezielt

Thu, 14 May 2026 17:49:01 +0200

Maven Profile gehören zu den Stellen in Maven, die am Anfang schnell unnötig kompliziert wirken. In der Praxis sind sie aber ziemlich nützlich, sobald du nicht mehr nur ein Projekt mit genau einer einzigen Ausführung hast. Ein typisches Beispiel: Lokal willst du dein Projekt mit anderen Einstellungen bauen als in einer CI-Pipeline oder für eine produktive Umgebung. Genau dafür sind Profile da.

Java Wrapper-Klassen verstehen - Autoboxing und Unboxing ganz entspannt

Mon, 11 May 2026 17:49:50 +0200

In Java arbeitest du nicht nur mit primitiven Datentypen wie int, double oder boolean, sondern auch mit den passenden Wrapper-Klassen wie Integer, Double und Boolean. Genau an dieser Stelle kommen Autoboxing und Unboxing ins Spiel. Die Begriffe klingen im ersten Moment technischer, als sie eigentlich sind. Am Ende geht es nur darum, dass Java in bestimmten Situationen automatisch zwischen einem primitiven Wert und dem passenden Objekt umwandelt.

Die wichtigste Zeile Code ist die, die du noch nicht schreibst

Sun, 10 May 2026 17:43:37 +0200

Gerade bei kleinen Projekten ist die Versuchung groß, direkt loszulegen. Du öffnest IntelliJ, legst ein neues Maven Projekt an, erstellst die ersten Klassen und denkst dir, dass du den Rest unterwegs schon klären wirst. Genau da beginnt oft das eigentliche Problem. Nicht, weil du zu wenig kannst, sondern weil dir vor der ersten Zeile Code noch das Bild vom Projekt fehlt.

Konzentriert programmieren - wie du dir als Einsteiger gute Arbeitsroutinen aufbaust

Fri, 08 May 2026 17:36:41 +0200

Produktiv zu arbeiten hat am Anfang wenig mit Geschwindigkeit zu tun. Es geht nicht darum, möglichst viele Zeilen Code zu schreiben oder in kurzer Zeit jedes neue Framework mitzunehmen. Produktiv bist du dann, wenn du mit klarem Kopf an einer Sache arbeitest, Fehler nachvollziehen kannst und am Ende des Tages weißt, was du geschafft hast. Genau das ist im Alltag oft schwieriger als gedacht. Nachrichten ploppen auf, irgendwo läuft Musik, jemand stellt dir eine Frage, du springst zwischen Tabs hin und her und plötzlich sind zwei Stunden weg, ohne dass du wirklich tief in einem Problem warst.

Abstrakte Klassen in Java - wann du sie wirklich brauchst

Wed, 06 May 2026 17:47:31 +0200

Wenn du in Java die ersten eigenen Klassen baust, wirkt eine abstrakte Klasse am Anfang oft unnötig kompliziert. Du schreibst normale Klassen, erzeugst Objekte mit new und kommst damit erst mal gut klar. Genau deshalb ist es sinnvoll, das Thema nicht über Definitionen zu verstehen, sondern über den eigentlichen Zweck.

JUnit in Java - was du wirklich testen solltest

Mon, 04 May 2026 17:36:19 +0200

JUnit gehört in Java-Projekten zu den Werkzeugen, die du früher oder später sowieso brauchst. Nicht, weil Tests gut klingen oder weil es in Tutorials oft so gemacht wird, sondern weil du mit Tests prüfen kannst, ob dein Code das tut, was du erwartest. Genau da liegt der eigentliche Wert. Ein Test ist kein Selbstzweck. Er gibt dir Sicherheit bei Änderungen, hilft dir beim Verstehen von Logik und macht Fehler sichtbar, bevor sie an einer anderen Stelle im Projekt auftauchen.

Java-Performance für Einsteiger: Kleine Ursachen, große Wirkung

Sat, 02 May 2026 17:42:16 +0200

Performance-Optimierung klingt am Anfang oft nach einem Thema für sehr große Systeme, sehr erfahrene Entwickler oder sehr spezielle Probleme. In der Praxis begegnet dir das aber deutlich früher. Nicht, weil jede Anwendung sofort extrem schnell sein muss, sondern weil sich kleine Ungenauigkeiten im Code mit echten Datenmengen, vielen Nutzern oder häufigen Aufrufen schnell bemerkbar machen. Was auf dem eigenen Rechner mit zehn Testobjekten unauffällig bleibt, kann in Produktion plötzlich langsam werden.

Was gutes Logging ausmacht und warum schlechte Logs Zeit kosten

Wed, 29 Apr 2026 17:50:04 +0200

Logging gehört zu den Dingen, die am Anfang oft nebensächlich wirken. Der Code läuft, die Ausgabe passt, also scheint alles in Ordnung zu sein. Spätestens wenn ein Fehler nur in einer bestimmten Umgebung auftritt, eine Anfrage unerwartet lange dauert oder ein Problem nicht sauber reproduzierbar ist, merkst du aber schnell, wie wichtig gute Logs sind. Ein sauberes Logging hilft dir nicht nur beim Debugging, sondern auch dabei, Anwendungen im laufenden Betrieb nachvollziehbar zu halten.

Zugriffsmodifikatoren in Java verstehen und sauber anwenden

Mon, 27 Apr 2026 17:44:06 +0200

Zugriffsmodifikatoren gehören zu den Grundlagen, die in Java sehr früh wichtig werden. Am Anfang wirken sie oft wie reine Syntax: public, private, protected oder einfach gar nichts. In der Praxis entscheiden sie aber darüber, welche Teile deines Codes von außen benutzt werden dürfen und welche nicht. Genau das macht sie so wichtig. Du legst damit fest, wo Verantwortung beginnt und wo sie endet. Wenn du das sauber machst, wird dein Code leichter verständlich, besser wartbar und deutlich robuster.

Master Git - so arbeitest du wie ein Profi statt wie ein Zufallsgenerator

Sat, 25 Apr 2026 17:53:33 +0200

Git ist schnell erklärt, aber nicht schnell verstanden. Genau da liegt meistens das Problem. Viele kennen ein paar Befehle, kommen im Alltag auch irgendwie durch und nutzen Git trotzdem eher wie eine Fernbedienung mit zu vielen Tasten. Das funktioniert, bis etwas schiefläuft. Dann wird aus git pull plötzlich Stress, aus einem Merge Konflikt ein Ratespiel und aus einem falschen Commit eine halbe Stunde Unsicherheit.

Tricky Java #2

Thu, 23 Apr 2026 17:50:12 +0200

In dieser Serie erwarten dich kleine, aber knifflige Java-Code-Schnipsel, die auf den ersten Blick völlig harmlos aussehen und genau deshalb besonders gefährlich sind.

Denn manchmal wird Code „moderner“ oder „schöner“ umgeschrieben, obwohl sich dabei unbemerkt das Verhalten ändert. Und genau so ein Fall ist mir heute begegnet.

Was dich in der Ausbildung zum Fachinformatiker für Anwendungsentwicklung wirklich erwartet

Tue, 21 Apr 2026 17:40:12 +0200

Wenn du darüber nachdenkst, eine Ausbildung zum Fachinformatiker für Anwendungsentwicklung zu machen, dann hast du wahrscheinlich viele Fragen im Kopf. Das ist völlig normal. Vielleicht fragst du dich, ob du schon programmieren können musst, ob Mathe ein Problem wird, wie ein typischer Arbeitstag aussieht oder ob sich der Einstieg in die IT überhaupt noch lohnt. Vor allem liest und hörst du gerade an vielen Stellen, dass wegen KI bald keine Junioren mehr gebraucht werden. Ich sage dir ganz klar: Genau daraus solltest du nicht den falschen Schluss ziehen.

Wiederverwendbare Business-Logik in Java EE: EJBs richtig schneiden

Sat, 18 Apr 2026 17:52:58 +0200

Wenn du zum ersten Mal eine Java-EE-Anwendung auf WildFly deployest, wirkt die Struktur oft wie ein Detail, das man „später“ aufräumt. Es läuft ja auch, wenn du alles in eine WAR packst. Genau deshalb stolpern viele erst dann über das Thema, wenn die Anwendung wächst oder wenn du dieselbe Logik an mehreren Stellen brauchst.

Warum Designprinzipien nicht immer die beste Antwort sind

Fri, 17 Apr 2026 17:33:58 +0200

Designprinzipien gehören zu den Themen, über die man in der Java-Welt relativ früh stolpert. Irgendwann tauchen dann Begriffe wie KISS, DRY, YAGNI oder SOLID auf, und plötzlich sieht es so aus, als gäbe es für jede Zeile Code eine feste Regel. Das Problem daran ist nicht, dass diese Prinzipien falsch wären. Das Problem ist eher, dass sie oft wie Naturgesetze behandelt werden, obwohl sie in der Praxis eher Orientierungshilfen sind.

Eventlistener in der Praxis: sauber registrieren, sauber entfernen

Wed, 15 Apr 2026 17:51:00 +0200

Eventlistener sind eines dieser Browser-Themen, die am Anfang “magisch” wirken: Du klickst irgendwo hin, drückst eine Taste, bewegst die Maus - und plötzlich läuft JavaScript-Code. Dahinter steckt kein Zauber, sondern ein ziemlich klarer Mechanismus: Der Browser feuert Events (Ereignisse) ab, und dein Code hängt sich mit einem Listener dran und reagiert darauf.

Abstract in Java: Der Bauplan für Profis einfach erklärt

Mon, 13 Apr 2026 17:40:00 +0200

Wenn du in Java auf das Schlüsselwort abstract stößt, wirkt das am Anfang oft wie eine unnötige Hürde. Warum sollte man eine Klasse schreiben, von der man gar kein Objekt erstellen kann? Um das zu verstehen, musst du kurz den Kopf von der Tastatur heben und in Konzepten denken. In der Softwareentwicklung geht es ständig darum, Gemeinsamkeiten zu finden und diese zu strukturieren. Das Wort "abstrakt" kommt aus dem Lateinischen und bedeutet so viel wie "abgezogen" oder "vom Besonderen losgelöst".

Der Ursprung, etwas richtig zu machen, ist immer, es falsch zu machen

Sun, 12 Apr 2026 17:41:00 +0200

Du kennst dieses Gefühl: Du schreibst Code, drückst auf „Run“ und der Compiler antwortet mit einer roten Wand aus Fehlermeldungen. Oder die Anwendung startet, aber „irgendwas“ ist komisch. Und irgendwo im Hinterkopf sitzt dieser Gedanke: „Vielleicht bin ich einfach nicht gut genug.“

Ich will dir heute eine These mitgeben, die wie ein mentaler Sicherheitsgurt funktionieren kann:

Der Ursprung, etwas richtig zu machen, ist immer, es falsch zu machen.

Und oft gilt sogar: Vieles, was wir heute „richtig“ nennen, hat historisch irgendwo mit einem Fehler angefangen.

Warum Maven Profiles dein Leben als Java-Entwickler leichter machen

Fri, 10 Apr 2026 17:46:06 +0200

Wenn du Java-Anwendungen entwickelst, kommst du an Maven nicht vorbei. Es verwaltet deine Abhängigkeiten und steuert den Build-Prozess. Aber oft stehst du vor dem Problem, dass deine Anwendung in verschiedenen Umgebungen unterschiedlich funktionieren muss.

Datentypen in Java ohne Stolperfallen

Wed, 08 Apr 2026 17:36:41 +0200

In Java unterscheidest du grob zwischen primitiven Datentypen und Referenztypen. Primitive Typen sind die Basis: Sie speichern den Wert direkt, ohne Objekt-Hülle. Das macht sie schnell, vorhersehbar und speichereffizient. Wichtig ist dabei: Die Größe der primitiven Typen ist in Java fest definiert und hängt nicht vom Betriebssystem ab. Genau diese Festlegung macht Code auf verschiedenen Plattformen so stabil.

Die Kunst, nervige Aufgaben zu lieben: Ein Guide für Devs

Tue, 07 Apr 2026 17:43:34 +0200

Das Leben als Softwareentwickler wird oft romantisiert. Man stellt sich vor, wie wir den ganzen Tag komplexe Algorithmen entwerfen, innovative Features bauen und dabei literweise Kaffee trinken, während wir uns wie Hacker in einem Film fühlen. Doch die Realität sieht oft anders aus, und das ist auch völlig in Ordnung. Es gibt Tage, an denen du vor Aufgaben sitzt, die auf den ersten Blick absolut keinen Spaß machen. Das können endlose XML-Konfigurationen in einem älteren JavaEE-Projekt sein, das Auflösen von Dependency-Konflikten in Maven oder das Schreiben von Dokumentationen für Code, den du nicht einmal selbst verfasst hast.

Overriding vs Overloading: Der Polymorphismus-Fallstrick in Java

Sat, 04 Apr 2026 17:55:14 +0200

Polymorphismus klingt irgendwie erstmal nach einem Wort aus dem Biologieunterricht oder nach einem mathematischen Konstrukt. In Java steckt dahinter aber etwas sehr Praktisches: Du schreibst Code, der mit verschiedenen konkreten Klassen arbeiten kann, ohne dass du überall Sonderfälle einbaust. Das macht deinen Code robuster, leichter testbar und oft auch deutlich übersichtlicher.

Warum System.out.println() kein Debugging ist

Thu, 02 Apr 2026 17:34:04 +0200

Du kennst das: Irgendwas funktioniert nicht, du hast keinen Plan warum, und der schnellste Griff geht zu System.out.println(). Einmal rauswerfen, nochmal laufen lassen, Ausgabe anschauen - fertig. Das fühlt sich an wie Debugging, ist es aber nicht. Es ist eher eine improvisierte Spurensuche mit Taschenlampe, während du eigentlich ein komplettes Werkzeugset neben dir liegen hast.

Eigene Annotationen bauen: Einfacher als du denkst

Tue, 31 Mar 2026 17:44:00 +0200

Annotationen in Java sind kleine Marker direkt im Code, die Zusatzinformationen tragen. Du kennst sie vermutlich schon: @Override, @Deprecated oder @SuppressWarnings. Das sind keine Kommentare und auch keine Magie im Sinne von "der Compiler macht irgendwas Unfassbares". Es ist eher wie ein sauberer Zettel am Code: "Dieses Element hat eine bestimmte Bedeutung". Entscheidend ist, wer diesen Zettel liest - der Compiler, dein IDE-Inspektor, ein Build-Tool oder ein Framework zur Laufzeit.

Wenn Zahlen lügen: Magic Numbers sauber ersetzen

Sun, 29 Mar 2026 17:53:13 +0200

Magic Numbers sind Zahlen (oder auch Strings), die irgendwo im Code „einfach so“ stehen und deren Bedeutung man nur errät. Du siehst dann 60, 3, 1024 oder "admin" und musst aus dem Kontext heraus rekonstruieren, warum genau dieser Wert dort steht. Zahlen im Code sind nicht per se schlecht. Schlecht wird es, wenn die Zahl eine fachliche oder technische Bedeutung trägt, diese Bedeutung aber nicht sichtbar ist.

Technische Schulden im Alltag: Erkennen, vermeiden, abbauen

Fri, 27 Mar 2026 17:49:32 +0100

Technische Schulden sind eines dieser Begriffe, die du früh hörst und erst später wirklich spürst. Gemeint ist kein “Fehler”, sondern eine bewusste oder unbewusste Abkürzung im Code oder in der Architektur, die dir heute Zeit spart und dich morgen Zeit kostet. Wie bei einem Kredit: Du bekommst sofort etwas, zahlst aber Zinsen, solange du die Sache nicht sauber nachziehst.

Ohne Konzept kein sauberer Code - und warum das kein Zufall ist

Thu, 26 Mar 2026 17:38:18 +0100

Wer mit Programmieren startet, stolpert früher oder später über Konzepte. Oft klingt das nach viel Papier, wenig Code und noch weniger Spaß. Genau deshalb wird das Thema gern ignoriert oder auf ein paar Stichpunkte runtergebrochen. Das Problem daran: Ohne ein sauberes Grundkonzept wird selbst ein kleines Projekt schnell unübersichtlich, fehleranfällig und unnötig kompliziert.

Lambdas und Streams - warum sie zusammen glänzen, aber getrennt verstanden werden müssen

Tue, 24 Mar 2026 17:30:27 +0100

Wenn man frisch mit modernerem Java unterwegs ist, hat man oft zwei Begriffe im Kopf, die irgendwie zusammengehören, aber trotzdem gerne durcheinander geraten: Lambdas und Streams. Beides wirkt auf den ersten Blick "neu und modern", beide tauchen gerne zusammen im Code auf - und zack, im Kopf verschwimmt das. In diesem Artikel trennen wir das sauber: Was ist ein Lambda, was ist ein Stream, warum ist das nicht das Gleiche und wie spielen die beiden trotzdem zusammen.

Heap, Stack und Metaspace - Warum Variablen verschwinden und Objekte nicht

Sun, 22 Mar 2026 17:14:01 +0100

Du hast sicher schon erlebt, dass eine Variable „weg“ ist, sobald eine Methode fertig ist. Gleichzeitig scheinen Objekte manchmal ewig zu leben - bis plötzlich der Speicher knapp wird. Das ist kein Zufall, sondern hängt daran, wo Java Dinge ablegt. Wenn du Heap, Stack und Metaspace einmal sauber auseinanderhalten kannst, werden viele typische Anfänger-Fragezeichen (und einige nervige Fehler) deutlich kleiner.

Programmieren lernen im Betrieb: Ehrliche Tipps für den Start

Sat, 21 Mar 2026 17:52:07 +0100

Der Einstieg in die Ausbildung als Programmierer ist spannend, manchmal chaotisch und oft anstrengender, als man am Anfang denkt. Du lernst nicht nur eine Programmiersprache, sondern ein komplettes Handwerk. Viele Dinge sieht man erst nach ein paar Monaten klarer, manche erst nach dem ersten Jahr. Dieser Artikel sammelt kurze und praxisnahe Tipps, die dir helfen sollen, schneller sicherer zu werden und typische Stolperfallen zu vermeiden.

Nebenläufige Programmierung

Thu, 19 Mar 2026 17:43:42 +0100

Nebenläufige Programmierung ist ein Begriff, der in der Softwareentwicklung häufig fällt, aber oft unterschiedlich interpretiert wird. Grundsätzlich beschreibt er die Fähigkeit eines Programms, mehrere Aufgaben gleichzeitig oder scheinbar gleichzeitig auszuführen. Dabei geht es nicht zwingend darum, dass der Prozessor tatsächlich mehrere Dinge exakt zur selben Zeit erledigt - sondern vielmehr darum, dass die Software so strukturiert ist, dass sie Aufgaben unabhängig voneinander bearbeiten kann. Das Ziel ist, Reaktionszeiten zu verbessern, Ressourcen effizienter zu nutzen und bestimmte Probleme überhaupt erst lösbar zu machen.

Wohin geht die Reise? Orientierung für deine Entwickler-Karriere

Tue, 17 Mar 2026 17:06:15 +0100

Der Einstieg in die IT fühlt sich oft klarer an als alles, was danach kommt. Du lernst programmieren, bekommst erste Aufgaben, schreibst Code, behebst Bugs und merkst relativ schnell, dass Softwareentwicklung mehr ist als Syntax und Frameworks. Irgendwann taucht dann zwangsläufig die Frage auf, wie es weitergeht. Nicht im Sinne von Titeln, sondern in Richtung Verantwortung, Fokus und persönlicher Entwicklung. Genau darum geht es hier: Welche realistischen Wege gibt es in der IT, wenn du als Entwickler Fuß gefasst hast, und was kommt nach den klassischen Stationen Junior, Entwickler und Senior.

Einstieg in JPA: Datenbankzugriff ohne SQL-Chaos

Sun, 15 Mar 2026 17:47:14 +0100

JPA gehört zu den zentralen Bausteinen moderner Java-Anwendungen, sobald persistente Daten ins Spiel kommen. Statt SQL-Statements überall im Code zu verteilen, kapselt JPA den Zugriff auf relationale Datenbanken sauber und objektorientiert. Du arbeitest mit Java-Objekten, während sich das Framework um Tabellen, Spalten und Joins kümmert. Das reduziert Boilerplate, verbessert die Lesbarkeit und macht fachlichen Code deutlich stabiler.

Code Smells - was riecht denn hier so streng?

Fri, 13 Mar 2026 17:35:21 +0100

Code Smells sind Hinweise darauf, dass im Code etwas nicht sauber ist - etwas schlecht riecht. Es geht nicht um Syntaxfehler oder Bugs, sondern um Strukturen, die dich langfristig ausbremsen. Der Code funktioniert vielleicht heute, aber er wird schwerer zu verstehen, zu testen und zu erweitern. Gerade in Java-Projekten sammeln sich solche Stellen schnell an, wenn man sie nicht bewusst wahrnimmt.

Algorithmen verstehen, besseren Java-Code schreiben

Wed, 11 Mar 2026 17:22:39 +0100

Algorithmen und Datenstrukturen begegnen dir früher oder später in jedem Java-Projekt. Oft wirken sie abstrakt, theoretisch oder wie etwas, das nur in Informatik-Vorlesungen relevant ist. In der Praxis sind sie jedoch ein zentrales Werkzeug, um sauberen, wartbaren und performanten Code zu schreiben. Es geht dabei nicht um komplizierte Mathematik, sondern um strukturierte Denkweisen.

Der unsichtbare Burnout-Treiber im Entwickleralltag

Tue, 10 Mar 2026 17:54:38 +0100

Der Job fühlt sich schwer an, obwohl dir das eigentliche Coden nach wie vor Spaß macht. Du sitzt vor sauberem Java-Code, kennst die Tools, weißt, was zu tun ist - und trotzdem bist du am Ende des Tages mental leer. Das ist kein Widerspruch. Sehr oft liegt das Problem nicht im Entwickeln selbst, sondern in dem, was permanent dazwischenfunkt.

JUnit Basics verständlich erklärt

Sun, 08 Mar 2026 17:45:13 +0100

JUnit ist das Standardwerkzeug für automatisierte Tests im Java-Umfeld. Wenn du mit Java arbeitest, wirst du früher oder später nicht daran vorbeikommen. Tests sind kein Selbstzweck und auch kein akademisches Konstrukt, sondern ein Werkzeug, das dir im Alltag hilft, Fehler früh zu erkennen und Änderungen sicher umzusetzen. Gerade bei wachsendem Codebestand ist das entscheidend.

Fachlogik zuerst: Ein Einstieg in Hexagonal Architecture

Fri, 06 Mar 2026 17:30:26 +0100

Hexagonal Architecture begegnet dir früher oder später, wenn Anwendungen größer werden und trotzdem wartbar bleiben sollen. Der Name klingt komplizierter, als das Konzept tatsächlich ist. Im Kern geht es darum, Abhängigkeiten sauber zu trennen und dein fachliches Modell vor technischen Details zu schützen. Genau das ist im Alltag mit Java, WildFly, Maven und Git entscheidend, wenn ein Projekt nicht nach kurzer Zeit unübersichtlich werden soll.

Warum guter Code mit Fehlern rechnet

Thu, 05 Mar 2026 17:14:05 +0100

Fehlermanagement ist eines der Themen, die am Anfang gerne unterschätzt werden. Der Code funktioniert, die Tests laufen, also weiter zum nächsten Feature. Spätestens wenn etwas schiefgeht, merkst du jedoch, wie wichtig ein sauberer Umgang mit Fehlern ist. Gute Fehlerbehandlung sorgt nicht nur dafür, dass dein Programm nicht abstürzt, sondern auch dafür, dass Probleme nachvollziehbar und lösbar bleiben.

Warum Rekursion weniger kompliziert ist, als sie aussieht

Tue, 03 Mar 2026 17:30:51 +0100

Rekursion gehört zu den Themen, die am Anfang oft für Verwirrung sorgen. Nicht, weil sie besonders kompliziert ist, sondern weil sie anders denkt als der klassische Schleifen-Code. Wichtig ist, dass du Rekursion nicht als Magie betrachtest, sondern als ein ganz normales Werkzeug, das man gezielt einsetzen kann. Denn im Kern bedeutet Rekursion lediglich: Eine Methode ruft sich selbst auf. Mehr ist es nicht. Der entscheidende Punkt ist, dass dieser Selbstaufruf kontrolliert passiert und irgendwann endet. Ohne ein klares Ende läuft dein Code unweigerlich in einen StackOverflowError. Genau deshalb besteht jede sinnvolle rekursive Methode immer aus zwei Teilen: einem Abbruchfall und einem rekursiven Schritt.

Maven für Einsteiger: Struktur, Abhängigkeiten und Build Cycle

Sun, 01 Mar 2026 17:49:47 +0100

Maven ist eines der zentralen Werkzeuge im Java-Ökosystem. Wenn du damit wenig Erfahrung hast, wirkt es am Anfang oft sperrig und unnötig komplex. In der Praxis löst Maven jedoch sehr konkrete Probleme: wiederholbare Builds, saubere Abhängigkeiten und eine klare Projektstruktur. Sobald du das Grundprinzip verstanden hast, wird Maven eher Werkzeug als Hürde.

Keine Panik vor dem roten Text: Ein Survival-Guide für den Start in die Java-Entwicklung

Thu, 26 Feb 2026 17:54:39 +0100

Wenn du gerade erst in die Softwareentwicklung startest, fühlt sich vieles wahrscheinlich an wie der Versuch, aus einem Feuerwehrschlauch zu trinken. Da ist diese riesige Menge an Technologien, Tools und Konzepten, die alle gleichzeitig auf dich einprasseln. Gestern hast du noch versucht, die Syntax einer For-Schleife unfallfrei hinzubekommen, und heute sollst du plötzlich verstehen, warum der Wildfly-Server dein Deployment ablehnt oder warum Maven den Build mit einer kryptischen Fehlermeldung abbricht.

JavaScript Events verstehen: onclick, onblur, onkeydown und onkeyup erklärt

Tue, 24 Feb 2026 17:23:50 +0100

Wenn du mit JavaScript anfängst, stolperst du relativ schnell über sogenannte Events. Damit reagiert dein Code auf Aktionen des Benutzers. Genau hier kommen Attribute wie onclick, onblur, onkeydown und onkeyup ins Spiel. Sie gehören zu den grundlegendsten Werkzeugen, um Webseiten interaktiv zu machen. In diesem Artikel schauen wir uns diese vier Events ruhig und praxisnah an, ohne Magie und ohne Abkürzungen.

Modular entwickeln: Wie Separation of Concerns (SoC) dir das Leben erleichtert

Sun, 22 Feb 2026 17:51:46 +0100

In der Softwareentwicklung begegnet dir irgendwann die Idee der Trennung von Verantwortlichkeiten - Separation of Concerns (SoC). Dieser Grundsatz stammt aus der Softwaretechnik und beschreibt das Aufteilen komplexer Systeme in kleinere Abschnitte, die jeweils nur einen bestimmten Aspekt behandeln. Der niederländische Informatiker Edsger W. Dijkstra prägte den Begriff 1974 und erklärte, dass wir Aspekte getrennt untersuchen sollten, damit wir uns jeweils auf eine Sache konzentrieren können. SoC bedeutet also nicht, alles zu isolieren, sondern klare Grenzen zu ziehen, damit du Effizienz, Korrektheit und Verständlichkeit separat betrachten kannst.

Java Annotationen selber bauen: kleines Beispiel, grosser Effekt

Fri, 20 Feb 2026 17:11:25 +0100

Wenn du in Java schon ein paar Klassen geschrieben hast, bist du Annotationen ziemlich sicher begegnet: @Override, @SuppressWarnings, vielleicht auch @Deprecated. Am Anfang wirken die Dinger wie „Meta-Kram“, den man halt drüber schreibt. In Wahrheit sind Annotationen ein sehr pragmatisches Werkzeug: du hängst einer Klasse, Methode oder einem Feld zusätzliche Informationen an, ohne deine eigentliche Logik damit zu vermischen.

Sauberer Java-Code mit Command–Query Separation

Wed, 18 Feb 2026 17:48:18 +0100

Wenn du anfängst, dich intensiver mit Softwaredesign zu beschäftigen, stolperst du relativ früh über Prinzipien mit großen Namen. Eins davon ist Command–Query Separation, kurz CQS. Klingt erstmal theoretisch, ist aber im Alltag extrem praktisch - gerade dann, wenn dein Code langsam größer wird und du nicht mehr jede Methode im Kopf behalten kannst.

Design Pattern

Tue, 17 Feb 2026 17:58:59 +0100

Design Pattern sind wiederkehrende Lösungen für häufig auftretende Probleme in der Softwareentwicklung. Sie sind kein fester Code, den man kopiert und einfügt, sondern eher ein Bauplan oder eine bewährte Idee, wie man ein bestimmtes Problem sauber, verständlich und flexibel lösen kann. Besonders in objektorientierten Sprachen wie Java helfen Design Patterns dabei, wartbaren und gut strukturierten Code zu schreiben. Für Einsteiger sind sie oft ein wichtiger Schritt, um vom reinen Programmieren hin zum echten Softwaredesign zu kommen.

REST Webservices in Java: Dein erster eigener API-Endpoint ohne Framework-Chaos

Sun, 15 Feb 2026 17:17:22 +0100

REST Webservices in Java klingen am Anfang gerne etwas abstrakt: HTTP, Ressourcen, JSON, Statuscodes, JAX-RS - ziemlich viele Begriffe auf einmal. In der Praxis ist das aber weniger Magie, als es aussieht. Wenn du Java schon ein bisschen kennst, kannst du mit ein paar Grundbausteinen sehr schnell deinen ersten eigenen REST-Webservice aufsetzen.

Zu viel Verantwortung im Code? Zeit für das Single Responsibility Principle

Fri, 13 Feb 2026 17:44:43 +0100

Wenn du dich noch nicht lange mit objektorientierter Programmierung beschäftigst, stolperst du relativ früh über die sogenannten SOLID-Prinzipien. Eines davon ist das SRP - das Single Responsibility Principle. Klingt erstmal theoretisch, ist in der Praxis aber eines der Prinzipien, die dir den grössten Hebel bringen, wenn dein Code wartbar bleiben soll.

Drei CSS-Konzepte, die dein Layout retten: Box-Modell, Kaskade, Spezifität

Wed, 11 Feb 2026 17:28:21 +0100

CSS wirkt am anfang oft harmlos: Ein paar Regeln, etwas Farbe, ein bisschen Abstand. Spätestens wenn Layouts unerwartet breiter sind, Styles sich gegenseitig aushebeln oder Änderungen scheinbar ignoriert werden, wird klar: hier greifen feste Mechanismen. Wenn du das Box-Modell, die Kaskade und die Spezifität verstanden hast, fällt ein grosser Teil dieses scheinbaren Chaos weg.

CompletableFuture - Asynchrone Programmierung einfach erklärt

Mon, 09 Feb 2026 17:56:00 +0100

Wenn du schon eine Weile mit Java arbeitest, bist du sicher über den Begriff Future gestolpert. Ein Future ist ein Platzhalter für ein Ergebnis, das erst in der Zukunft verfügbar ist - also das Ergebnis einer asynchronen Operation. Doch das klassische Future hat seine Grenzen: Du kannst es nicht elegant kombinieren, keine Callbacks anhängen und musst aktiv warten, bis das Ergebnis da ist. Genau hier kommt CompletableFuture ins Spiel.

Webentwicklung beginnt nicht im Controller: Ein realistischer Blick auf die Basics

Sun, 08 Feb 2026 17:50:54 +0100

Wenn du als Programmeinsteiger heute unterwegs bist, hast du oft schon früh Kontakt mit Java oder einer anderen Programmiersprache. Klassen, Methoden, Interfaces, vielleicht sogar schon Streams oder erste JavaEE-Projekte. Der Code sieht sauber aus, Tests laufen, der Build ist grün. Und dann kommt das erste Webprojekt und plötzlich wird es unruhig.

Erst denken, dann coden: Requirements Engineering für Einsteiger

Sat, 07 Feb 2026 17:55:54 +0100

Wenn du noch nicht so lange programmierst, kennst du das vermutlich: Jemand erklärt dir kurz, was gebaut werden soll, du denkst dir "passt, hab ich verstanden" und legst los. Zwei Tage später stellt sich heraus: Missverständnis. Der Fachbereich wollte etwas anderes, ein wichtiger Fall wurde vergessen oder eine scheinbar kleine Anforderung zieht auf einmal einen Rattenschwanz an Änderungen hinter sich her.

Funktionale vs. nicht funktionale Anforderungen – der Unterschied, den Anfänger oft übersehen

Thu, 05 Feb 2026 17:36:00 +0100

Wenn du Software entwickelst, stolperst du früher oder später über die Begriffe "funktionale Anforderungen" und "nicht funktionale Anforderungen". Diese tauchen in Fachbüchern, in Tickets und in Meetings auf, oft so, als wäre das alles selbstverständlich. Ist es aber nicht - gerade als Einsteiger fühlt sich das schnell nach Theorie-Kauderwelsch an.

Fail Fast statt spät kaputt: Sauberer Java-Code durch klare Vorbedingungen

Tue, 03 Feb 2026 17:54:22 +0100

Wenn du gerade erst mit dem Programmieren in Java startest, wirst du relativ schnell über einen Begriff stolpern: "Fail Fast". Klingt erstmal nach einem fancy Buzzword, steckt aber etwas sehr Handfestes dahinter: Der Code soll möglichst früh, möglichst klar und möglichst laut kaputtgehen, wenn etwas nicht stimmt. Genau darum geht es hier.

Vibe-Coding: Abkürzung oder Lernbooster?

Sun, 01 Feb 2026 17:46:58 +0100

Mit „Vibe-Coding“ meine ich eine Art zu programmieren, bei der du dich stark auf das Gefühl verlässt: Du beschreibst eine Aufgabe in natürlicher Sprache, eine KI liefert Code, und du übernimmst ihn, weil er plausibel aussieht und schnelle Ergebnisse bringt. Das kann von „schreib mir eine Utility-Methode“ bis hin zu „baue mir einen REST-Endpunkt mit Validierung“ reichen. Der Vorteil liegt auf der Hand: Du kommst zügig in Bewegung, bekommst Beispiele, Formulierungen und Strukturen, die du sonst erst mühsam zusammensuchen würdest.

Der Comparator in Java: Dein Werkzeug für präzise und flexible Sortierungen

Thu, 29 Jan 2026 17:57:07 +0100

Der Comparator begegnet dir in Java spätestens dann, wenn du anfängst, Listen nicht nur "irgendwie", sondern gezielt nach bestimmten Eigenschaften sortieren zu wollen. Vielleicht willst du Modelle nach einem Feld ordnen, Daten fürs Frontend vorbereiten oder einfach nur eine Liste von Objekten sauber und strukturiert ausgeben. Genau hier spielt der Comparator seine Stärken aus: Du kannst Vergleichslogik definieren, ohne deine Klassen selbst anzupassen, und behältst dabei volle Kontrolle über das Sortierverhalten.

Streams in Java - der moderne Ansatz für sauberen und ausdrucksstarken Code

Tue, 27 Jan 2026 17:45:37 +0100

Streams sind eine der Sachen in Java, die am Anfang ein bisschen ungewohnt aussehen, aber im Alltag extrem praktisch werden. Gerade wenn du noch nicht lange programmierst, wirkt der "Punkt-Operator-Marathon" schnell nach "Magie". In Wirklichkeit ist das Ganze aber ziemlich bodenständig: Streams helfen dir dabei, mit Datenfolgen (Listen, Arrays, Sets, whatever) lesbarer und kürzer zu arbeiten.

Lambdas in Java - kompakt, flexibel und überraschend mächtig

Sun, 25 Jan 2026 17:32:16 +0100

Lambdas in Java wirken am Anfang ein bisschen abstrakt: Pfeile, viele runde Klammern und irgendwo soll dann "funktionale Programmierung" passieren. In Wahrheit sind Lambdas aber vor allem eins: eine kompakte Schreibweise um dir das Leben im Alltag mit Java deutlich leichter zu machen.

In diesem Artikel schauen wir uns an, was Lambdas sind, wofür du sie brauchst und wie du den Aufbau Schritt für Schritt verstehst. Das Ziel: Du sollst nachher ohne Bauchschmerzen ein einfaches Lambda schreiben können und ungefähr wissen, was in der Sprache im Hintergrund passiert.

Was lebenslanges Lernen für Entwickler wirklich bedeutet

Fri, 23 Jan 2026 17:36:32 +0100

Als Programmierer zu arbeiten bedeutet lebenslanges Lernen; diesen Satz hast du vermutlich schon häufiger gehört. Er klingt schnell nach Druck, nach Verpflichtung und vielleicht sogar danach, dass man permanent etwas verpassen könnte. Doch eigentlich beschreibt er einen ganz natürlichen Prozess.

Commit-Nachrichten sind keine Nebensache

Wed, 21 Jan 2026 18:16:38 +0100

Commit-Nachrichten sind oft das unterschätzteste Werkzeug in der Softwareentwicklung. Während Code-Qualität, Architekturentscheidungen oder Testabdeckung regelmäßig im Mittelpunkt stehen, geraten Commit-Messages häufig in den Hintergrund. Dabei sind sie weit mehr als nur ein notwendiger Begleittext für Versionskontrollsysteme. Sie sind ein zentraler Bestandteil der Kommunikation im Entwicklungsteam und ein wichtiges Werkzeug für Wartung, Nachvollziehbarkeit und Qualitätssicherung. Wer sie stiefmütterlich behandelt, schafft langfristig Probleme - für sich selbst und für alle, die am gleichen Projekt arbeiten.

Java Beans - das Herz vieler Java-Anwendungen

Mon, 19 Jan 2026 17:39:08 +0100

Wenn man anfängt, Java zu lernen, stößt man früher oder später auf den Begriff Bean. Viele kennen Java Beans vielleicht vom Hörensagen oder aus Frameworks wie Spring oder Jakarta EE, aber was genau ist eigentlich eine Bean, und warum ist sie so wichtig? In diesem Beitrag schauen wir uns das Thema Schritt für Schritt an - ganz ohne Fachchinesisch, aber mit vielen praktischen Beispielen.

Wie man mit Git arbeitet und warum

Sat, 17 Jan 2026 17:50:20 +0100

Git ist eines dieser Werkzeuge, das am Anfang wie ein unbezwingbarer Berg aussieht. Viele Begriffe wirken abstrakt, und der Workflow erscheint kompliziert. Doch sobald man die Grundprinzipien verstanden hat, wird Git zu einem deiner verlässlichsten Begleiter im Entwickleralltag. In diesem Beitrag möchte ich dir die wichtigsten Git Basics vermitteln - praxisnah und so verständlich wie möglich.

Die Kaffeepause

Thu, 15 Jan 2026 17:34:19 +0100

Es gibt diese Tage im Entwicklerleben, an denen du eigentlich ganz optimistisch startest: Du setzt Dich an den Rechner, öffnest deine IDE, nimmst einen ersten kleinen Schluck aus deiner Tasse, eher aus Gewohnheit als aus Notwendigkeit, und denkst: „Heute wird ein guter Tag.“ Und theoretisch hätte das sogar stimmen können, wäre da nicht der Umstand, dass Projekte, Anforderungen und Realität selten genau nach deinem Plan arbeiten.

Das Lasten- und Pflichtenheft

Tue, 13 Jan 2026 17:59:22 +0100

Wer in der Softwareentwicklung an professionellen Projekten mitarbeitet, trifft früher oder später auf zwei zentrale Dokumente: das Lastenheft und das Pflichtenheft. Beide klingen zunächst ähnlich, erfüllen aber unterschiedliche Aufgaben. Für Einsteigerinnen und Einsteiger, die zum ersten Mal mit Kundenanforderungen, technischen Entscheidungen oder Projektplanung zu tun haben, lohnt sich ein genauer Blick auf diese beiden Begriffe. Sie helfen dabei, ein gemeinsames Verständnis zwischen allen Beteiligten zu schaffen und sorgen dafür, dass ein Projekt nicht in die falsche Richtung läuft.

Warum kleine Programmier-Projekte keine Verschwendung sind

Sat, 10 Jan 2026 17:36:24 +0100

Wer mit dem Programmieren beginnt, stößt früher oder später auf die Frage, ob sich kleine Projekte eigentlich lohnen. Gemeint sind kurze Experimente, ein einzelnes Feature, ein Mini-Tool oder ein winziges Spiel, das vielleicht nie jemand außer dir selbst sieht. Auf den ersten Blick wirken solche Vorhaben unscheinbar und manche Einsteiger fragen sich, ob sie ihre Zeit nicht besser in ein großes, umfassendes Projekt investieren sollten. Doch genau hier liegt ein weit verbreitetes Missverständnis.

Was ist eigentlich Ajax?

Fri, 09 Jan 2026 17:30:42 +0100

Ajax ist eines dieser Themen, das man am Anfang häufig hört, aber selten wirklich versteht. Und das ist völlig normal. Wenn man frisch in der Java-Entwicklung mit JSF einsteigt, prasseln viele Konzepte gleichzeitig auf einen ein: Managed Beans, Scopes, XHTML, Komponenten, Navigation - und dann ruft plötzlich jemand: "Mach das doch einfach per Ajax!"

In diesem Beitrag zeige ich dir ganz einfach und praxisnah, wie Ajax in JSF und PrimeFaces funktioniert, warum es so hilfreich ist und wie du es selbst einsetzen kannst. Du brauchst dafür keine Vorkenntnisse über komplexe Webtechnologien. Alles, was du brauchst, ist etwas Neugier und die Bereitschaft, ein paar Zeilen Code auszuprobieren.

Reflection in Java - Flexibilität mit Risiko

Tue, 06 Jan 2026 17:33:54 +0100

Reflection in Java ist eines der spannendsten, aber auch eines der am häufigsten missverstandenen Themen unter Programmier-Einsteigern. Gerade zu Beginn wirkt es wie Magie: Du kannst zur Laufzeit Informationen über Klassen abrufen, Methoden aufrufen, Felder lesen oder setzen und sogar Objekte instanziieren, ohne die Klasse vorher zu kennen. Genau diese Flexibilität ist mächtig - aber sie bringt auch Risiken mit sich. In diesem Beitrag möchte ich dir Reflection so erklären, dass du sie wirklich verstehst, und gleichzeitig ein Gefühl dafür bekommst, wann du sie einsetzen solltest und wann nicht.

Der Unterschied zwischen strukturierter, prozedualer und objektorientierter Programmierung

Sat, 03 Jan 2026 17:49:19 +0100

Wer mit der Programmierung beginnt, begegnet früher oder später drei grundlegenden Denkweisen: der strukturierten, der prozedualen und der objektorientierten Programmierung. Diese Begriffe wirken anfangs technisch und abstrakt, beschreiben aber im Kern nur unterschiedliche Arten, wie ein Problem in klaren Schritten gelöst und wie Code organisiert werden kann. Wer die Unterschiede versteht, kann besser einschätzen, warum moderne Anwendungen so aufgebaut sind, wie sie sind, und wie sich Programme sinnvoll strukturieren lassen. Besonders in einer Sprache wie Java ist dieses Wissen entscheidend, um robuste und wartbare Software zu schreiben.

Warum ich meine Blogbeiträge auf Deutsch schreibe

Thu, 01 Jan 2026 17:36:15 +0100

Es gibt diese Momente im Leben eines Entwicklers, in denen man sich fragt: „Warum tue ich mir das eigentlich an?“
Nein, ich spreche nicht von den Tagen, an denen der Build 20 Minuten braucht, um mir dann mitzuteilen, dass irgendwo ein Semikolon fehlt. Ich spreche vom Lernen selbst - diesem aufregenden, aber manchmal auch nervenaufreibenden Abenteuer, in dem man jeden Tag ein kleines bisschen besser versteht, was im Hintergrund eigentlich passiert.

Maven - was ist das überhaupt?

Tue, 30 Dec 2025 17:21:49 +0100

Maven ist für viele Java-Einsteiger eines der ersten Werkzeuge, die ihnen im Projektalltag begegnen. Und oft wirkt es am Anfang abstrakt: eine pom.xml, viele unbekannte Elemente, fremde Ordnerstruktur, automatische Downloads - was passiert hier eigentlich? Als Ausbilder sehe ich immer wieder, wie sehr Maven den Einstieg erleichtern kann, wenn man einmal verstanden hat, was es macht: Es organisiert dein Projekt, verwaltet Abhängigkeiten, baut dein Programm und sorgt dafür, dass es auf jedem Rechner gleich gebaut werden kann. In diesem Beitrag führe ich dich Schritt für Schritt durch die Grundlagen.

Fehleranalyse - Wenn der Teufel im Detail steckt

Sat, 27 Dec 2025 17:17:47 +0100

Fehleranalyse in komplexen JavaEE-Anwendungen wirkt für viele Einsteiger zunächst wie ein undurchsichtiger Prozess. Im Alltag treffen unterschiedliche Frameworks, Serverkonfigurationen, Datenbanken und Frontend-Komponenten aufeinander. Wenn irgendwo etwas nicht so funktioniert, wie es soll, entsteht schnell das Gefühl, den Überblick zu verlieren. Dabei ist erfolgreiche Fehlersuche weniger eine Frage des Bauchgefühls als vielmehr eine Frage strukturierter Vorgehensweisen. Wer versteht, wie Fehler entstehen und wie sie sich in einer typischen JavaEE-Umgebung äußern, kann systematisch, ruhig und zielgerichtet arbeiten. Genau das schafft langfristig Sicherheit im Umgang mit komplexen Systemen.

Zu viel KI, zu wenig Substanz: wie AI Slop Wissen langfristig verändert

Thu, 25 Dec 2025 17:28:12 +0100

Wenn du den Begriff "AI Slop" zum ersten Mal hörst, klingt das ein bisschen nach Fast Food für Daten: schnell, billig, füllend, aber meistens eher fragwürdig. Gemeint ist im Kern genau das: KI-generierter Müll, der das Netz und zunehmend auch die echte Welt zumüllt. Text, Bilder, Videos, Produkte, Services - alles, was sich halbautomatisch mit künstlicher Intelligenz erzeugen lässt, landet irgendwo im Umlauf. Und die entscheidende Frage ist nicht mehr, ob uns das gefällt, sondern wie wir damit leben, weil: Das geht nicht wieder weg.

Es ist nie zu spät, neu anzufangen

Wed, 24 Dec 2025 17:04:10 +0100

Wir werden ja alle nicht jünger - und irgendwie ist das auch gut so. Der Jungbrunnen muss erst noch erfunden werden oder wurde bislang einfach noch nicht entdeckt. Die Zeit schreitet unaufhörlich voran, und gefühlt hat sie das noch nie so schnell getan wie heute. Gerade in der Welt der Technik jagt ein Meilenstein den nächsten. Wir entwickeln Neues, bevor wir das Alte überhaupt richtig verstanden oder hinterfragt haben. Manchmal habe ich das Gefühl, die Welt rennt - und wir müssen entscheiden, ob wir mitlaufen oder stehen bleiben.

Immutability – Warum Unveränderlichkeit so wichtig ist

Mon, 22 Dec 2025 17:36:51 +0100

Wenn du in Java programmierst, wirst du früher oder später auf den Begriff Immutability stoßen. Wörtlich übersetzt bedeutet das „Unveränderlichkeit“. Eine immutable Klasse ist also eine Klasse, deren Objekte nach ihrer Erstellung nicht mehr verändert werden können.

Equals, HashCode und toString richtig implementieren

Sat, 20 Dec 2025 17:48:24 +0100

Wer in Java eigene Klassen schreibt, kommt früher oder später an den Punkt, an dem equals(), hashCode() und toString() relevant werden. Diese drei Methoden stammen alle aus der Klasse Object, also der obersten Basisklasse in Java. Deshalb hat jede Klasse sie automatisch - aber oft reicht die Standard-Implementierung nicht aus. Besonders wenn du Objekte miteinander vergleichen oder in Collections wie HashSet oder HashMap speichern möchtest, wird es wichtig, diese Methoden richtig zu überschreiben.

Der Unterschied zwischen „funktioniert“ und „ist fertig“

Thu, 18 Dec 2025 17:47:12 +0100

Es gibt einen entscheidenden Moment in der Softwareentwicklung, an dem sich zeigt, ob jemand wirklich verstanden hat, was professionelles Programmieren bedeutet: der Moment, in dem der Code zwar „funktioniert“, aber noch längst nicht „fertig“ ist. Viele verwechseln diese beiden Zustände. Ein Stück Software, das „funktioniert“, erfüllt vielleicht auf den ersten Blick seinen Zweck – es liefert das erwartete Ergebnis, zeigt keine offensichtlichen Fehler und läuft ohne Absturz. Doch „fertig“ ist sie erst, wenn sie auch in einem halben Jahr, nach mehreren Änderungen, neuen Anforderungen und einem anderen Entwickler am Code, noch zuverlässig und nachvollziehbar funktioniert.

Text-Blöcke in Java

Mon, 15 Dec 2025 17:53:04 +0100

Wer schon ein paar Monate mit Java arbeitet, kennt das Problem: Man möchte längere Texte in seinen Code schreiben - etwa ein JSON, ein SQL-Statement oder einfach einen mehrzeiligen String. Und dann beginnt das Chaos. Überall Anführungszeichen, Escape-Zeichen und Zeilenumbrüche mit \n. Der Code wird unübersichtlich und fehleranfällig. Genau hier kommen Textblöcke ins Spiel - eine der angenehmsten Neuerungen, die Java in den letzten Jahren eingeführt hat.

MagicSudoku

Sun, 14 Dec 2025 10:00:05 +0100

Statt Word-Ratespiel gibt’s heute Zahlenlogik: Magic Sudoku ist das tägliches 9×9-Puzzle für alle, die sonst nur mit 0 und 1 arbeiten. Die Regeln sind simpel: In jeder Zeile, Spalte und in jedem 3×3-Block dürfen die Zahlen 1–9 nur einmal vorkommen. Alles andere ist „Bug“.

Jeden Tag wartet ein neues Sudoku auf dich. Sobald du es gelöst hast, wird dein Erfolg lokal im Browser gespeichert - und du siehst, wann das nächste Daily freigeschaltet wird.

Bereit für ein bisschen „Constraint-Debugging“ ohne IDE? Löse das Daily, kopiere dein Ergebnis (inkl. Zeit) und zeige der Welt, dass du nicht nur Code, sondern auch Logik sauber zu Ende bringst.

Viel Spaß!

Static vs. Instanzkontext - Wo Java-Einsteiger ins Stolpern geraten

Sat, 13 Dec 2025 17:49:31 +0100

Einer der häufigsten Stolpersteine für Programmieranfänger in Java ist das Thema static vs. Instanzkontext. Viele stoßen beim Lernen schnell auf Fehlermeldungen wie „non-static variable cannot be referenced from a static context“ und wissen nicht genau, warum das passiert. In diesem Beitrag möchte ich dir anschaulich erklären, was es mit diesen beiden „Welten“ auf sich hat, wann du was verwendest und warum dieser Unterschied in Java so wichtig ist.

Code ist Kommunikation - nicht nur für Compiler

Thu, 11 Dec 2025 17:52:48 +0100

Wenn man über Programmierung spricht, denkt man oft an Logik, Algorithmen und Syntax. Doch im Kern ist Code mehr als nur eine Abfolge von Befehlen, die ein Computer ausführt. Code ist Kommunikation – eine Form des Ausdrucks zwischen Menschen, die eine Maschine als Übersetzer nutzt. Der Compiler mag der erste sein, der den Code liest, aber er ist nicht der wichtigste Adressat. Der wichtigste Leser ist immer ein Mensch.

Willkommen in der Realität der Softwareentwicklung

Wed, 10 Dec 2025 17:50:02 +0100

Du sitzt vor deinem Rechner, IntelliJ ist offen, der Cursor blinkt. Vielleicht hast du gerade deine ersten Schritte mit Java hinter dir, verstehst die Syntax, weißt, was eine Klasse und was ein Objekt ist. Und dann öffnest du GitHub oder Stack Overflow und wirst erschlagen. Docker, Kubernetes, Wildfly, Maven, Jakarta EE, Microservices, CI/CD, Cloud Native. Die Liste der Buzzwords scheint endlos und jeden Tag kommt ein neues Framework dazu, das angeblich alles verändert. Da kommt schnell das Gefühl auf, dass du niemals genug wissen wirst, um in diesem Job wirklich gut zu sein. Atme tief durch. Das ist völlig normal. Willkommen in der Realität der Softwareentwicklung.

Lokale Variablen mit var? Das ist doch JavaScript, oder?

Mon, 08 Dec 2025 17:42:04 +0100

Wenn du in den letzten Jahren mit Java gearbeitet hast, ist dir vielleicht schon das Schlüsselwort var begegnet. Ja, du hast richtig gelesen: in Java! Denn schon seit Java 10 kannst du damit lokale Variablen deklarieren, ohne ihren Typ explizit anzugeben. Das ist eine praktische Erweiterung - aber wie so oft in der Programmierung steckt der Teufel im Detail. Heute schauen wir uns an, was var genau macht, wann es hilfreich ist und wann du lieber darauf verzichten solltest.

MagicWordle

Sun, 07 Dec 2025 12:00:00 +0100

Statt gewöhnlicher Alltagsbegriffe erwarten dich hier ausschließlich Wörter aus der Welt der Programmierung, Softwareentwicklung und IT. Von bekannten Basics bis zu fiesen Fachbegriffen - nur wer Code liebt oder täglich damit kämpft, hat hier echte Chancen. Jeden Tag erwartet dich ein neues Rätsel welches es zu lösen gilt. Kein Problem für dich, oder?

Bist du bereit, dein Entwicklerwissen unter Beweis zu stellen? Teile dein Ergebnis und beweise, dass dein Entwicklerego vollkommen zurecht existiert!

Das Builder Pattern - verständlich erklärt

Fri, 05 Dec 2025 17:51:11 +0100

Wenn du schon einmal ein Objekt mit vielen Parametern im Konstruktor hattest, weißt du, wie schnell der Code unübersichtlich wird. Besonders bei Klassen, die viele optionale Eigenschaften haben, kann das Lesen und Erstellen solcher Objekte mühsam werden. Genau hier hilft das Builder Pattern. Es sorgt dafür, dass dein Code besser lesbar, wartbarer und weniger fehleranfällig wird.

try-with-resources - endlich kein Ressourcen-Chaos mehr

Wed, 03 Dec 2025 17:42:35 +0100

Wenn man in Java mit Dateien, Streams oder Datenbanken arbeitet, stößt man schnell auf das Thema Ressourcenmanagement. Vielleicht kennst du das Problem: Du öffnest eine Datei, liest etwas heraus und am Ende musst du sie wieder schließen. Klingt einfach, aber was passiert, wenn mitten im Code eine Exception geworfen wird? Wird die Ressource dann trotzdem geschlossen? Genau dafür gibt es seit Java 7 eine elegante Lösung: try-with-resources.

Optionals in Java - warum sie so wichtig sind und wie du sie richtig einsetzt

Mon, 01 Dec 2025 17:49:12 +0100

Wenn du mit Java arbeitest, wirst du früher oder später auf das Thema Optional stoßen. Gerade für Einsteiger ist das anfangs oft verwirrend. Warum braucht man das überhaupt? Wieso kann man nicht einfach null verwenden? Und wie geht man richtig damit um? In diesem Beitrag möchte ich dir zeigen, was Optional ist, wofür es gedacht ist und wie du es praktisch einsetzen kannst, um sauberen, lesbaren und sicheren Code zu schreiben.

Pattern Matching for instanceof

Sat, 29 Nov 2025 17:58:56 +0100

Wer mit Java arbeitet, kennt den Operator instanceof wahrscheinlich schon länger. Er wird genutzt, um zu prüfen, ob ein Objekt einer bestimmten Klasse oder einem bestimmten Typ entspricht. Doch seit Java 16 gibt es eine deutliche Verbesserung: Pattern Matching für instanceof. Diese Neuerung sorgt nicht nur für kompakteren Code, sondern macht ihn auch sicherer und besser lesbar - besonders für Einsteiger ist das ein echter Gewinn.

Sealed Classes? Was ist denn das schon wieder?

Thu, 27 Nov 2025 17:46:42 +0100

Sealed Classes wurden mit Java 17 eingeführt und sind eines dieser Features, das man beim ersten Lesen vielleicht überfliegt, aber beim genaueren Hinsehen richtig spannend wird - vor allem, wenn man versteht, wofür sie gedacht sind. In diesem Beitrag möchte ich dir als Einsteiger zeigen, was es mit Sealed Classes auf sich hat, warum sie nützlich sind und wie du sie praktisch einsetzen kannst.

Sealed Classes erlauben dir, ganz genau festzulegen, welche Klassen oder Interfaces von einer bestimmten Klasse erben dürfen. Damit bekommst du mehr Kontrolle über deine Vererbungshierarchie, ohne gleich alles mit final oder Paketgrenzen zu „verbauen“. Es ist also eine Art „gezielte Freiheit“ in der Vererbung.

Geduld ist ein Feature, kein Bug

Tue, 25 Nov 2025 17:34:50 +0100

Es gibt kaum eine Eigenschaft, die in der Softwareentwicklung so unterschätzt wird wie Geduld. Dabei ist sie - und das meine ich vollkommen ernst - kein Hindernis, kein Mangel an Tempo oder Motivation. Sie ist ein Feature. Ein entscheidendes. Wer langfristig gute Software schreiben will, wer mit anderen zusammenarbeitet, wer junge Entwickler ausbildet oder Verantwortung trägt, wird früher oder später verstehen: Ohne Geduld läuft gar nichts. Und da muss ich mir immer wieder selbst an die eigene Nase fassen und mich auch immer wieder ehrlich selbst reflektieren.

Verantwortung im Team: Wenn dein Code nicht nur deiner ist

Sat, 22 Nov 2025 17:26:07 +0100

In der Softwareentwicklung wird oft von Zusammenarbeit, Teamgeist und Kommunikation gesprochen - doch einer der zentralsten Aspekte dieser Zusammenarbeit ist Verantwortung. Nicht Verantwortung im Sinne von „Wer ist schuld, wenn etwas schiefgeht“, sondern im Sinne von Bewusstsein: das Bewusstsein dafür, dass jede einzelne Codezeile, die man schreibt, Auswirkungen auf andere hat. Diese Verantwortung trägt jeder Entwickler, ob Berufseinsteiger oder Senior, ob Backend, Frontend oder Fullstack.

Eine neue (alte) Welt: JSF

Wed, 19 Nov 2025 17:58:07 +0100

Wenn man zum ersten Mal mit Jakarta Server Faces (JSF) arbeitet, wirkt vieles zunächst etwas „magisch“. Plötzlich erscheinen Daten im Browser, ohne dass man genau weiß, wie sie dorthin kommen. Doch wenn man einmal verstanden hat, wie JSF im Hintergrund arbeitet, wird schnell klar, dass es sich um ein mächtiges Framework handelt, das die Entwicklung von serverseitigen Webanwendungen in Java stark vereinfacht. In diesem Beitrag schauen wir uns die Grundlagen von JSF an, verstehen den Lebenszyklus und lernen, wie man einfache Seiten mit Eingabeformularen und Ausgaben erstellt.

Was ist künstliche Intelligenz eigentlich?

Mon, 17 Nov 2025 18:09:05 +0100

Künstliche Intelligenz, kurz KI, ist längst mehr als ein Schlagwort aus der Forschung. Sie hat sich zu einem festen Bestandteil moderner Softwareentwicklung entwickelt und beeinflusst, wie Anwendungen entworfen, entwickelt und betrieben werden. Dabei ist es wichtig zu verstehen, was genau hinter den Begriffen steckt, die in diesem Zusammenhang häufig fallen – Begriffe wie Machine Learning, Neural Network, LLM oder Prompt. Nur wer die grundlegenden Konzepte kennt, kann die Möglichkeiten und Grenzen dieser Technologie realistisch einschätzen.

Kennzeichnungspflicht für KI-Inhalte ab 2026: Was Blogger wissen sollten

Sun, 16 Nov 2025 18:40:43 +0100

Voraussichtlich ab dem 02.08.2026 tritt die neue Verordnung (EU) 2024/1689 - häufig KI-VO oder AI Act genannt - weitgehend in Kraft. Damit kommen unter anderem Kennzeichnungspflichten für Inhalte, die durch KI erstellt oder manipuliert wurden.

Enums, EnumSet & EnumMap in Java – einfache Helfer mit grosser Wirkung

Fri, 14 Nov 2025 18:09:20 +0100

Wer mit Java arbeitet, trifft früher oder später auf sogenannte Enums. Für Einsteiger wirken sie anfangs vielleicht etwas seltsam – man könnte ja auch einfach Konstanten mit public static final definieren. Doch Enums bieten viel mehr: sie sind typsicher, leicht erweiterbar und lassen sich hervorragend mit speziellen Sammlungen wie EnumSet und EnumMap kombinieren. In diesem Beitrag zeige ich dir, wie du diese Werkzeuge effektiv einsetzt.

Java Collections verstehen (List, Set, Map, Queue)

Wed, 12 Nov 2025 18:02:50 +0100

Wer mit Java anfängt, stößt sehr schnell auf den Begriff Collection. Gemeint ist damit nicht einfach irgendeine Liste, sondern ein ganzes Framework – also eine Sammlung von Schnittstellen und Klassen, die es uns ermöglichen, Daten komfortabel zu speichern, zu durchsuchen und zu verarbeiten. Für viele Einsteiger ist das am Anfang ein undurchsichtiger Dschungel: ArrayList, HashSet, HashMap, LinkedList – was ist was, und wann verwende ich welches?

In diesem Beitrag möchte ich dir Schritt für Schritt zeigen, wie du die wichtigsten Typen der Java Collections verstehst und wie du sie praktisch einsetzen kannst. Wir konzentrieren uns dabei auf die vier Grundtypen: List, Set, Map und Queue. Ziel ist, dass du am Ende intuitiv weißt, wann du welche Datenstruktur verwendest und warum.

Java: Sichtbarkeiten - Das Geheimnisprinzip einfach erklärt

Mon, 10 Nov 2025 17:32:33 +0100

In der objektorientierten Programmierung geht es nicht nur darum, was ein Programm kann, sondern auch darum, wer was wissen darf. Genau hier setzt das sogenannte Geheimnisprinzip an – oder etwas technischer formuliert: die Sichtbarkeit von Variablen, Methoden und Klassen in Java.

Das Ziel ist einfach: Eine Klasse soll nur so viel preisgeben, wie wirklich nötig ist. Alles andere bleibt intern und damit geschützt vor unbeabsichtigtem Zugriff von außen. Das ist ein wichtiger Teil von sauberem Code und schützt vor Fehlern, die durch falsche Nutzung entstehen könnten.

Die mündliche Abschlussprüfung zum Fachinformatiker*in für Anwendungsentwicklung (Abschlusspräsentation)

Sun, 09 Nov 2025 18:05:55 +0100

Die Präsentation in der IHK-Abschlussprüfung zum Fachinformatiker Anwendungsentwickler ist für viele Auszubildende der letzte große Schritt vor dem erfolgreichen Abschluss der Ausbildung. Sie bietet die Gelegenheit, das eigene Projekt noch einmal kompakt und verständlich darzustellen – nicht nur technisch, sondern auch kommunikativ. Dabei geht es nicht allein um das Zeigen von Quellcode oder Architekturdiagrammen, sondern vor allem darum, die Prüfer davon zu überzeugen, dass man das Projekt versteht, es selbstständig durchgeführt hat und die fachlichen Entscheidungen nachvollziehbar begründen kann.

Interceptoren in Java - kleine Helfer mit großer Wirkung

Sat, 08 Nov 2025 18:39:29 +0100

Wenn man mit JavaEE (oder JakartaEE, wie es heute heißt) arbeitet, begegnet man früher oder später einem ziemlich mächtigen, aber oft übersehenen Konzept: den Interceptoren. Interceptoren sind kleine Klassen, die sich zwischen den Aufruf eines Methodenaufrufs und dessen tatsächliche Ausführung schalten. Sie können also Code ausführen, bevor oder nachdem eine Methode läuft – ohne, dass man diesen Code in jeder einzelnen Methode wiederholen muss.

Wie man Fehler eingesteht – und warum das die beste Entwicklerqualität ist

Fri, 07 Nov 2025 18:09:52 +0100

Es gibt kaum einen Beruf, in dem man so oft scheitert, wie in der Softwareentwicklung. Wir alle schreiben Code, der nicht funktioniert. Wir alle deployen Features, die unerwartete Nebenwirkungen haben. Und wir alle haben schon mal eine Datenbank gelöscht, ein Build-Skript ruiniert oder eine Endlosschleife in Produktion geschickt. Der Unterschied zwischen einem guten und einem schlechten Entwickler liegt dabei nicht darin, ob er Fehler macht – sondern wie er damit umgeht.

Mergekonflikte – wo Sorgfalt wichtiger ist als Geschwindigkeit

Wed, 05 Nov 2025 10:45:00 +0100

Es gibt Momente in der Softwareentwicklung, in denen man merkt, dass Technik allein nicht reicht. Mergekonflikte gehören genau in diese Kategorie. Sie sind nicht das Ergebnis eines Fehlers oder Unvermögens, sondern schlicht ein Zeichen dafür, dass mehrere Menschen gleichzeitig an demselben Projekt arbeiten – mit unterschiedlichen Ideen, unterschiedlichen Aufgaben und manchmal auch unterschiedlichen Ansätzen. Und genau hier zeigt sich, wer wirklich versteht, was gemeinsames Entwickeln bedeutet.

Der StackTrace - Fehlermeldungen verstehen lernen

Wed, 05 Nov 2025 10:06:01 +0100

Wenn du länger mit Java arbeitest, wirst du irgendwann unweigerlich auf ihn treffen: den StackTrace.
Dieses oft einschüchternd wirkende Konstrukt aus Zeilen voller Klassen, Methoden und Zeilennummern ist in Wahrheit einer deiner besten Freunde. Ein StackTrace verrät dir nämlich ganz genau, was schiefgelaufen ist, wo es passiert ist und oft auch warum.

Doch viele Einsteiger sehen ihn zum ersten Mal, bekommen große Augen und schließen schnell das Fenster. Das ist schade, denn wer lernt, einen StackTrace zu lesen, spart sich Stunden an Fehlersuche.

Java, Java SE, JDK, JRE, Java EE? Was soll das?

Sat, 18 Oct 2025 19:21:24 +0200

Wenn man mit Java anfängt, stolpert man schnell über verschiedene Begriffe wie Java SE, JDK, JRE oder Java EE oder auch Jakarta EE und ganz ehrlich: Das kann am Anfang ziemlich verwirrend sein.
Was gehört zusammen? Was braucht man zum Programmieren? Und was bedeutet das alles überhaupt?

Serialisierung in Java

Thu, 02 Oct 2025 19:06:04 +0200

Wenn du schon eine Weile mit Java arbeitest, bist du sicher auf den Begriff Serialisierung gestoßen. Aber was bedeutet das eigentlich? Und warum sollte man es brauchen?

In diesem Beitrag erkläre ich dir Schritt für Schritt, was Serialisierung ist, wofür man sie verwendet, und zeige dir ein paar praxisnahe Beispiele.

WAR vs. EJB: Die Unterschiede einfach erklärt

Sun, 20 Jul 2025 18:27:24 +0200

Heute nehmen wir uns diese Akronyme vor. Wir schauen uns an, was sie bedeuten, wofür du sie brauchst und wo die feinen, aber wichtigen Unterschiede liegen – besonders im Kontext deiner Java EE-Web-Anwendungen.

MavenBuildManager - Schluss mit Maven-Chaos auf dem Desktop

Wed, 28 May 2025 18:14:55 +0200

Viele Java-Entwickler kennen das Problem: Ein ganzer Zoo aus Projekten, unterschiedliche Java-Versionen, fragmentierte Build-Optionen – und dazu die Frage: Mit welcher Java-Version wurde dieses Projekt eigentlich gebaut?

Und spätestens wenn man zwischen mehreren Java-Versionen, verschiedenen Maven-Profilen oder Build-Parametern jonglieren muss, wird aus dem einfachen mvn clean install schnell eine frustrierende Fehlerquelle.

Was ist eigentlich ein DTO?

Mon, 26 May 2025 15:12:47 +0200

In der Welt der Java-Entwicklung stößt man früher oder später auf den Begriff DTO – kurz für Data Transfer Object. Gerade in größeren Anwendungen oder beim Arbeiten mit Daten aus Datenbanken, REST-Schnittstellen oder Microservices ist es ein häufig verwendetes Muster. Doch was genau ist ein DTO, warum braucht man es, und wie unterscheidet es sich von anderen Objekten wie POJOs oder Java Records?

Die main-Methode - Was passiert beim Start einer Java-Anwendung

Sat, 24 May 2025 16:49:12 +0200

Viele Anfänger schreiben ihre ersten Zeilen Java-Code, kompilieren die Datei und führen das Programm über die Konsole aus – ohne sich Gedanken darüber zu machen, was da eigentlich im Hintergrund passiert. Dieser Beitrag zeigt dir Schritt für Schritt, wie Java-Programme starten, warum die main()-Methode so wichtig ist, und was dabei unter der Haube abläuft.

Library vs. Framework

Thu, 22 May 2025 18:27:10 +0200

In der Softwareentwicklung stolpert man schnell über die Begriffe Library und Framework.Beide liefern fertige Bausteine, um schneller ans Ziel zu kommen. Doch obwohl sie sich ähnlich anhören, bzw. im allgemeinen Sprachgebrauch auch oft verwechselt werden, verfolgen sie ganz unterschiedliche Prinzipien. In diesem Artikel schauen wir uns die Unterschiede an – praxisnah und mit Beispielen aus Java sowie HTML, CSS und JavaScript.

Warum die Browserwahl wichtiger ist denn je

Mon, 19 May 2025 16:25:27 +0200

Als Google im Jahr 2023 begann, den neuen Erweiterungsstandard Manifest v3 in Chrome einzuführen, ging ein spürbarer Ruck durch die Internet-Community. Die Kritik war laut: Werbeblocker wie uBlock Origin sollten kastriert werden, Nutzerfreiheiten eingeschränkt und die Kontrolle über den eigenen Browser geschwächt werden. Doch trotz all der Diskussionen blieb die große Wechselwelle aus. Und auch als Google Manifest v2 endgültig den Stecker gezogen hat– Chrome ist weiterhin der dominierende Browser weltweit.

Einstieg in JavaScript – So funktioniert die Sprache im Browser

Fri, 16 May 2025 19:17:50 +0200

JavaScript ist eine der wichtigsten Sprachen der Webentwicklung. Nachdem du in meinem letzten Beitrag bereits erfahren hast, was JavaScript überhaupt ist, schauen wir uns heute an, wie JavaScript funktioniert, welche Besonderheiten es gibt, und was du beim Start wissen solltest.

Tricky Java #1

Tue, 13 May 2025 10:03:43 +0200

Welcher Wert wird auf der Konsole ausgegeben:

public class Test {
    public static void main(String[] args) {
        int x = 10;
        int y = ++x + x++ + ++x;
        System.out.println(y);
    }
}

Antwortmöglichkeiten:

33
34
35
Compilation Error

Step-by-Step zur Lösung:

Wie man vielleicht auf den ersten Blick schon erkennt, geht es hier um die Behandlung von ++x sowie x++, also das Inkrementieren eines Wertes und den exakten Zeitpunkt, wann genau das stattfindet.

Lass uns das zunächst mal etwas besser aufschreiben, damit das auch deutlich wird:

int y = (++x) + (x++) + (++x);

Dabei kann man sich folgendes merken:

++x: Der Wert wird VOR dem Zugriff um 1 erhöht

x++: Der Wert wird NACH dem Zugriff um 1 erhöht

Dann gehen wir die Aufgabe mal der Reihe nach durch:

int y = ++x

Gemäß unseres Merksatzes wird also x VOR dem Zugriff um 1 erhöht was bedeutet, dass x an dieser Stelle den Wert 11 hat.

int y = ++x +

Hier ist ein ganz normaler Operator um die einzelnen Ergebnisse zu addieren

int y = ++x + x++

x++ bedeutet nach unserem Merksatz, dass der Wert von x erst NACH dem Zugriff um 1 erhöht wird, also hat x zu diesem Zeitpunkt noch den Wert 11.

int y = ++x + x++ +

Hier ist wieder ein normaler Operator um die einzelnen Ergebnisse zu addieren

int y = ++x + x++ + ++x

Das ist nun der tricky Teil: x wird hier VOR dem Zugriff um 1 erhöht, erhält aber durch den Vorgänger (NACH dem Zugriff) noch ein plus 1, sodass x hier den Wert 13 hat! (12 wegen der Erhöhung vorher, 13 wegen der Erhöhung VOR diesem Zugriff).

Dadurch ergibt sich: int y = 11 + 11 + 13 welches in Summe dann 35 ergibt.

Die richtige Lösung lautet also C.

Dies ist ein schönes Beispiel um sich das Thema gut merken zu können und ich bin mir sicher, wenn man das einmal raus hat, ist es auch gar nicht mehr so schwer.

Wie fandest du die Aufgabe? Hast du auf den ersten Blick die richtige Lösung gefunden oder hast du die Step-by-Step Lösung benötigt?

Was ist eigentlich JavaScript?

Sat, 10 May 2025 17:44:35 +0200

JavaScript ist aus der modernen Webentwicklung nicht mehr wegzudenken – und doch ranken sich viele Missverständnisse um diese Programmiersprache. Manche glauben, sie hätte etwas mit Java zu tun, andere halten sie grundsätzlich für unsicher oder sogar für ein Datenschutzrisiko. Zeit also, mit einigen Mythen aufzuräumen und einen fundierten Überblick zu geben: Was ist JavaScript eigentlich wirklich, wofür wird es verwendet, und warum ist es längst viel mehr als nur eine „Skriptsprache für Webseiten“?

Java Interview-Fragen: #5 Multithreading

Mon, 05 May 2025 18:00:11 +0200

Kürzlich habe ich einen Artikel gelesen, in dem es um Fragen in einem Vorstellungsgespräch als Java-Entwickler ging. Es wurden einige Fragen vorgestellt und die These aufgestellt, dass die meisten Bewerber diese Fragen nicht beantworten können.