Java Clean Code Kurs

Qualität des Java-Codes und Teamproduktivität erhöhen

Sie können bereits programmieren, wollen aber künftig einen hochwertigeren, saubereren und weniger fehleranfälligen Code erzeugen? Dann Sind Sie in diesem Kurs richtig. Der Clean Code Kurs bringt Ihren Code auf das nächste Level und erhöht nachweislich Produktivität und Qualität. Erfahren Sie hier mehr über unser Clean Code Seminar.

Vorteile

  • Schneller Einstieg in Clean Code: kompakt und praxisorientiert
  • Deutliche Verbesserung der Qualität Ihres Codes
  • Geringere Einarbeitungszeit für neue Mitarbeiter  Reduzierung der starken Abhängigkeit von Top-Programmierern
  • Schnellerer Programmiererfolg dank leicht adaptierbarem Clean Code
  • Kompetente Trainer: Buchautoren und Universitätsdozenten
  • Individuelle Betreuung: wir gehen gezielt auf jeden Teilnehmer ein Maßgeschneiderte Themen: wir berücksichtigen so weit wie möglich Ihre Vorkenntnisse, Wunschthemen und Schwerpunkte
  • Intensive Betreuung: maximal 8 Teilnehmer
  • Nachhaltige Betreuung, falls Sie später Fragen zu den Inhalten haben
  • Praxisorientiert: 30% Theorie und 70% Praxis
  • Kompakt: auf das für die Praxis Wesentliche optimiert (3 statt 5 Tage)
  • Hochwertiges Lernmaterial und viele Programmieraufgaben
  • Moderne Laptops während der Schulung -ohne Aufpreis!
  • Schönes Ambiente inklusive Verpflegung: Getränke, Vormittagssnack, warmes Mittagessen, Kaffee und Kuchen inklusive

Inhalte

Clean Code Seminar Inhalt

Der Clean Code Kurs ist ein praxisorientierter Kurs, basierend auf dem Standardwerk „Clean Code“ von Robert Martin. Kombiniert mit unseren jahrelangen Erfahrungen aus Industrie- und Akademie.

  • Code Rote
  • Clean Code
  • Names Rules
  • Function Rules
  • Exception Rules
  • Good Comments
  • Bad Comments
  • Object-Oriented Programming
  • SOLID Principle
  • Boundaris
  • Unit Tests 
  • Test Driven Development TDD
  • Important Refactoring Patterns
  • Code Smells: Names
  • Code Smells: Function 
  • Code Smells: Comments
  • Code Smells: Test 
  • Über 15 kleine Workshop
  • Abschluss Projekt

Ausführliche Themen finden Sie unten unterAGENDA

Ziele

  • Clean Code Stil lernen und im Unternehmen adaptieren
  • Hochwertigen Java Code mit Clean Code und SOLID Regeln schreiben können
  • Clean Code Regeln für Identifier, Kommentare und Methoden beherrschen und anwenden können
  • Existierenden Java Code optimieren und besser strukturieren können
  • Schlechten Code anhand von "Code Smells" Regeln erkennen können
  • Schlechten Code eliminieren können
  • Den Aufwand des Debuggings und Refactorings minimieren
  • Produktivität, Leistung und Qualität deutlich maximieren

Zielgruppe

Der Java Clean Code Kurs wurde konzipiert für Software-Entwickler und Programmierer mit soliden und guten Java-Kenntnissen. Zuvor haben Sie vielleicht unseren Java Grundkurs, das Java Aufbauseminar oder ein anderes Clean Code Seminar besucht. Allerdings ist dies keine Voraussetzung für diesen Kurs. Lediglich der Umgang mit den theoretischen Java Strukturen sollte Ihnen geläufig sein.

Beschreibung

Das Clean Code Seminar ist auf drei Tage angesetzt und ideal für Java-Programmierer, die den eigenen oder fremden Code in einen deutlich besseren Code verwandeln möchten. Besserer Code bedeutet dabei: klar strukturiert, sehr gute Lesbarkeit, kompakt und effizient. Ein solcher Code weist eine hohe Qualität auf und zeichnet sich dadurch aus, dass er leicht zu verstehen und zu erweitern ist. Damit ist dieser sogenannte Clean Code sehr flexibel, was auch großen Entwicklerteams ermöglicht, schnell auf neue Anforderungen oder Änderungen zu reagieren. Auch die komplexesten Anwendungen lassen sich mit Clean Code schneller, sicherer und vor allem für andere nachvollziehbar programmieren. Dies ist sehr hilfreich für Ihre Mitarbeiter, Ihren Arbeitgeber oder Ihre Kunden, die auf Ihrem Code aufbauen möchten.

Was lernen Sie am ersten Tag?

Als Motivation für dieses spannende und wichtige Thema befassen wir uns zunächst mit den vier Symptomen von schlechtem Code und schlechter Architektur (Rigidity, Fragility, Inseparability und Opacity) und versetzen uns in die Rolle eines Managers, dessen Projekt sehr langsam voran kommt und ständig Fehler produziert. Deadlines werden nicht eingehalten, Teams sind genervt und Kunden empört und unzufrieden. Wir eruieren, was er nun tun sollte aus welchen Gründen. Anschließend widmen wir uns dem Begriff "Clean Code": Worum handelt es sich dabei, woran erkennt man guten Code und wie kann man stilsicheren Clean Code schnell erlernen? Um Clean Code zu erzeugen, müssen wir bestimmte Regeln und Techniken an verschiedenen Stellen in unserem Java-Programm einsetzen. Java-Programme bestehen in der Regel aus mehreren Klassen und Interfaces. Wir zerlegen nun eine Java-Klasse in ihre grundlegenden Bestandteile: Identifier (Klassennamen, Variablennamen, Packagenamen, Methodennamen), Kommentare, Methoden, und ggf. auch eine Ausnahmebehandlung. Dabei ergeben sich viele interessante Fragen: Wie sollten meine Identifier heißen? Wie lang sollten sie sein? Wie viele Zeilen sollte meine Methode haben? Wie viele Parameter sollte sie idealerweise haben? Wann sollte sie void und wann sollte sie einen Wert aus einem bestimmten Datentyp zurückliefern und warum? Wann sollte ich auf eine Ausnahmebehandlung zurückgreifen, zuerst oder zuletzt? Wie sieht der Abstraktionslevel bei meinen Methoden und meinem Code aus? Mit allen diesen Fragen werden wir uns bei den Clean Code Regeln für Identifier, Kommentare, Methoden und Ausnahmebehandlungen befassen, und zwar anhand von zahlreichen interaktiven Code-Beispielen (Vor/Nach bzw. schlechter Code/guter Code) sowie kleinen Programmieraufgaben

Was lernen Sie am zweiten Tag?

Nach dem ersten Tag beherrschen Sie bereits alle wichtigen Regeln zum Erzeugen von Clean Code allerdings nur innerhalb einer Klasse. Am zweiten Tag widmen wir uns den Fragen: Wie sollten unsere Klassen miteinander interagieren, wie sollten wir Klassen so designen, dass neue Anforderungen idealerweise nur durch Erweiterungen und nicht durch Modifizieren und Ändern von vorhandenem Code möglich wird. Wie und wann zerlege ich meine Klasse in mehreren Klassen und warum? Wie kann ich Team A und Team B Module zuweisen, so dass beide Teams unabhängig voneinander entwickeln? Was bedeutet die Regel: "Programm to an interface not implementation", die wir in jedem Fachbuch über Clean Architektur und Code lesen? Wie setzen wir das richtig um? Alle diese Fragen werden wir mit sogenannten SOLID und GRASP Prinzipien beantworten, anhand von spannenden Code-Beispielen und Programmieraufgaben. SOLID steht als Abkürzung für 5 Techniken (Single Responsibility Principle, Open/Closed Principle, Liskov Substitution Principle, Interface Segregation Principle und Dependency Inversion Principle). SOLID zeichnet sich unserer Erfahrung nach dadurch aus, dass es nicht einfach zu planen oder umzusetzen ist. Aber wenn ein Programmier SOLID beherrscht, dann sieht er sofort und auf Anhieb ob sein Programm SOLID verletzt oder nicht. Sollte sein Programm SOLID verletzen, dann kann er sich fragen, warum: Gibt es gute Gründe dafür? Sollte die Antwort Nein lauten, dann kann er jetzt sehr leicht seinen Code derart ändern, dass er die SOLID-Regeln nicht mehr verletzt. Wir finden die Bezeichnung "Principle" allerdings etwas übertrieben: SOLID sind sehr gute Clean Code und Architektur-Regeln, deren Anwendung normalerweise zu einem gut strukturierten und klar definierten Code führt. Dennoch sollte und darf man SOLID nicht immer blind einsetzen. Es gibt ab und an auch gute Gründe, die gegen SOLID sprechen. Die SOLID-Regeln machen den Code flexibel, bringen aber auch mehr Komplexität mit sich. Man muss fast immer Kompromisse eingehen: Braucht man die Flexibilität, dann muss man auch die Komplexität in Kauf nehmen. Daher sollte sich jeder Programmierer immer die Frage stellen: Warum habe ich SOLID verletzt? Gibt es dafür gute Gründe? Auf jeden Fall sollte jeder gute Programmierer die SOLID-Regeln beherrschen, zu seinem Know-How und Werkzeugkasten hinzufügen und mit gesundem Menschenverstand anwenden. Um das alles nicht zu abstrakt zu behandeln, werden Sie alle SOLID-Regeln mittels kleiner Programmieraufgaben umsetzen und sich selbst ein Bild davon machen, ob und wann sich das für Sie lohnt. Wir wollen Clean Code erzeugen, einen Code der nicht nur leicht zu verstehen ist, sondern der vor allem auch richtig funktioniert. Daher gehören auch die Themen Unit Testing und Test Driven Development (TDD) hier zweifellos dazu. Wir unternehmen einen schnellen Exkurs in JUnit 5 und auch in TDD, welches aus 3 Phasen (RED-GREEN-REFACTORING) besteht. Durch einfache Beispiele und Programmieraufgaben werden Sie diese 3 Phasen in Aktion kennen lernen und schnell ein Gefühl dafür bekommen. Wenn Sie sich mehr für Unit Testing und TDD interessieren, können Sie auch unseren separaten Kurs Java Unit Testing an der Münchner Coding Akademie besuchen.

Was lernen Sie am dritten Tag?

Nun kennen Sie bereits alle wichtigen Clean Code Regeln für eine und mehrere Klassen und dazu sogar noch Unit Testing. Was jetzt noch fehlt: In großen Projekten müssen Sie meist mit einem Code arbeiten, den Sie nicht selbst geschrieben haben. Sie sollen neuen Code aufbauend auf vorhandenem Code schreiben und müssen diesen dafür verstehen und ggf. modifizieren und erweitern. Woran können Sie nun erkennen, ob die vorhandene Code-Qualität gut genug ist oder nicht? Die Antwort ist relativ einfach: Wenn der vorhandene Code die Clean Code und SOLID-Regeln verletzt und dazu keine oder nur schlechte Tests hat, dann ist die Wahrscheinlichkeit ziemlich hoch, dass es sich um Code mit schlechter Qualität handelt. Genau dafür gibt es einen Katalog für die sogenannten Code Smells: Als Code Smells bezeichnet man Code, der nach Fehlern und Komplexität riecht. Dies ist sogar noch sehr diplomatisch ausgedrückt. Code Smells ist Code der einfach stinkt, weil er derart schlecht geschrieben ist. Ein solcher schlechter Code bremst die Entwicklung und verringert die Produktivität und Freude am Programmieren. Der erste Schritt um solchen schlechten Code zu beseitigen, ist die sofortige Erkennung desselben; dies ist zunächst eine reine Übungs- und Erfahrungssache. Dennoch gibt es einen Katalog für Code Smells (Names, Functions, Comments und Test Smells) mit über 20 Patterns. Wir sehen uns die wichtigsten Patterns, mit denen man aus schlechtem Code guten Code machen kann, mittels vieler Code-Beispiele und Best Practice Techniken an. Diese Aufgabe: schlechten Code in guten Code zu verwandeln - ist extrem wichtig und sehr anspruchsvoll, denn sie erfordert die Kenntnisse von Refactoring Patterns und kann nur durch intensive Übung und viele Programmieraufgaben erlernt werden. Aus diesem Grund bieten wir dafür zusätzlich einen Kurs "Improve Your Java Code" an, der für das Arbeiten mit Legacy Code der ideale Begleiter ist.

Die Trainer

Einer der folgendern Trainer wird das Java Clean Code Kurs Seminar durchführen:

Trainer: Allaithy Raed

Allaithy Raed

Java Trainer, Coach, Consultant und Geschäftsführer
Experte für Java, Python, Clean Code, Clean SW-Architektur, Refactoring, Testing, Train The Trainer

Mehr Infos

Trainer: Dr. Matthias Hölzl

Dr. Matthias Hölzl

Ehemaliger Professor für Software and Computational Systems Engineering an der LMU München
Experte für Python, Java, C++, JavaScript, Clean Architektur, Künstliche Intelligenz, Agile Methoden

Mehr Infos

Trainer: Prof. Dr. Peer Kröger

Prof. Dr. Peer Kröger

Professor für künstliche Intelligenz und Datenbank an der Ludwig-Maximilians-Universität München
Experte für Künstliche Intelligenz, Data Mining, Maschinelles Lernen, Python, Datenbank

Mehr Infos

Agenda

Der Java Grundkurs wurde für 3 Tage konzipiert. Innerhalb dieser drei intensiven Tage vermitteln wir Ihnen ausnahmslos alles, was Sie als Java Einsteiger benötigen. Das spart Zeit und damit bares Geld. Für jedes Thema gibt es Beispiele und Programmieraufgaben. Die Theorie Anteil beträgt  20% und die Praxisanteil von 80%. Es gibt über 14 kleine Workshops und am dritten Tag ein Abschluss-Projekt  Folgende Themen lernen Sie in unserem Java Grundkurs für Anfänger 

Clean Code Tag 1

Code Rote

  • The Company killed by Code
  • Productivity Problem
  • Manager Reaction
  • Code Rote: Rigidity
  • Code Rote: Fragility
  • Code Rote: Inseparability
  • Code Rote: Opacity

Clean Code

  • Clean Code after Grady Boosch
  • Clean Code after Bjarne Stroustrup
  • Clean Code after Ward Cunningham
  • Clean Code after Michael Feathers

Name Rules

  • What is a good name?
  • What is a bad name?
  • Ottinger’s Rules for good names
  • Intention-Revealing Names
  • Pronounceable Names
  • Searchable Names
  • Describe the Problem not the Implementation
  • Avoid Disinformation
  • Make Meaningful Distinctions
  • Avoid Encodings like Hungarian Notation
  • Choose Parts of Speech Well
  • Use Scope Length Rules

Function Rules

  • What is a function?
  • Function Grammars
  • Big Function
  • Extract till you drop
  • Step-Down Rule
  • Function Type Rules
  • Command-Query Separation Rule
  • Command-Query Separation Rule in Threads
  • Tell, Don’t Ask Principle
  • Train Wrecks
  • The Law of Demeter
  • Parameter List Rules
  • Use Maximal three Arguments
  • No Output Argument Rule
  • No Boolean Argument Rule
  • No null Argument Rule
  • Statement Block Rules
  • Do One Thing Rule
  • One Level of Abstraction Rule
  • Small Function Rule
  • Big Functions hide Classes Rule
  • Minimize Side-Effects
  • Avoid and Minimize Swicth Statement

Error Handling Rules

  • What is Exception and Error Handing?
  • Error Handling First Rule
  • Prefer Exception over special Values
  • Use the most suitable Exception Classes
  • Use Unchecked Exceptions (RuntimeException

Good Comments

  • Good Comments
  • Legal Comments
  • Informative Comments
  • Explanation of Intent
  • Clarification
  • Warning of Consequences
  • TODO Comments
  • Amplification
  • Javadocs in Public APIs

Bad Comments

  • Mumbling
  • Redundant Comments
  • Misleading Comments
  • Mandated Comments
  • Journal Comments
  • Noise Comments
  • Scary Noise

Clean Code Tag 2

Object-Oriented Programming

  • What is Object-Oriented Programming?
  • Dependency Management in OOP
  • Dependency Inversion
  • Switch Statement and OOP
  • Switch Statement and the Fan-Out Problem

Solid Principles

  • Single Responsibility Principle
  • Open/Closed Principle
  • Liskov Substitution Principle
  • Interface Segregation Principle
  • Dependency Inversion Principle

Boundries

  • The Main Area
  • Learning Boundries
  • Clean Boundaries

Unit Test

  • Introduction to JUnit 5
  • Test Life Cycle
  • Junit 5 Annotations
  • Junit 5 Assertion Methods

Test-Driven Development TDD

  • What is Test-Driven Development TDD?
  • RED Phase
  • GREEN Phase
  • REFACTORING Phase

Imortant Refactoring Patterns

  • Rename Pattern
  • Move-to Pattern
  • Extract Method Pattern
  • Extract Class from a Big Method Pattern
  • Extract an Interface Pattern

Clean Code Tag 3

Code Smells: Names

  • Choose Descriptive Names
  • Choose Names at the Appropriate Level of Abstraction
  • Use Standard Nomenclature Where Possible
  • Unambiguous Names
  • Use Long Names for Long Scope
  • Avoid Encodings
  • Name Should Describe Side-Effects

Code Smells: Functions

  • Too Many Arguments
  • Output Arguments
  • Flag Arguments
  • Dead Function

Code Smells: Comments

  • Inapproprate Information
  • Obsolete Comment
  • Redundant Comment
  • Poorly Written Comment
  • Commented-Out Code

Code Smells: Test

  • Insufficient Tests
  • Use a Coverage Tool
  • Don’t Skip Trivial Tests
  • Test Ambiguity
  • Test Boundary Conditions
  • Exhaustively Test Near Bugs
  • Patterns of Failure Are Revealing
  • Test Coverage Patterns Can Be Revealing
  • Tests Should Be Fast

Zertifikat

Krönender Abschluss Ihres Java Clean Code Seminars ist die feierliche Übergabe Ihres persönlichen Zertifikats. Dieses werden Sie sich nach den drei Seminartagen zu Recht verdient haben. Schließlich gelingt Ihnen die Abschlussarbeit garantiert im Handumdrehen. Als Inhaber des Coding Akademie Zertifikats sind Sie auf dem Markt gefragter denn je. Denn gute Programmierer gibt es viele, aber nur wenige Programmierer mit gutem Clean Code. Darum ist das Zertifikat bei Arbeitgebern und Seminarteilnehmern gleichermaßen begehrt.