Clean Code Principles with Handson for Java and Python

Apply snake_case naming for Python methods and arguments, and refactor hardcoded constants to improve reusability while calculating a 20% discount on the unit price.

Improve code readability by using descriptive names for methods and variables, such as rename the method to calculate discount and the variable to discounted amount.

Write meaningful comments that explain code logic, such as fetching customer details by a customer ID from a database or API, including found and not-found handling.

Apply clean code principles by breaking a multi-purpose function into single action based functions: validate customer, calculate values, aggregate data, and format output.

Illustrate how to separate concerns by decoupling discount logic into two functions: one computes the discount percentage from price, the other calculates the final price, improving readability and testability.

Define a proper Java project structure that clearly separates src/main/java, src/test/java, and resources, organizing code into controller, service, repository, dto, models, and entity for readability, reusability, and maintainability.

Follow proper naming conventions in Java for classes, interfaces, constants, methods, and variables to clearly convey intent, using camel casing, uppercase constants, and meaningful names.

Explore practical naming conventions in Java, illustrating class names with capitals, constants in all caps, and variables and methods in camel case, plus lowercase package names.

Avoid creating unnecessary objects to prevent memory leaks and improve performance, using static factory methods instead of constructors to reuse instances.

Identify a memory leak by contrasting creating a new list inside a loop with initializing the list once, and adding objects repeatedly.

Explore the structure of a Java source file by examining package statements, static and non-static imports, the single public class rule, constructors, fields, and member methods that implement business logic.

Explore documentation comments for classes and functions and implementation or block level comments for complex code to help future reviewers understand logic and reasons, preventing confusion and saving development time.

Document java code with javadoc class, constructor, author, and method comments for a pojo employee model, and illustrate block level comments describing loops and salary logic.

Group parameters into a single object to reduce method parameter count, improving readability and decreasing scope confusion, while avoiding clean code violations detected by SonarQube; pass only necessary parameters.

Learn to reduce method parameter clutter by encapsulating related fields in an employee class, then pass the employee object and department as separate arguments to avoid sonar cube violations.

Learn when to use double quotation marks for strings and single quotation marks for characters, with examples of string concatenation to improve readability and code clarity.

Learn to write proper, readable code with fixed line length, clear indentation, and line breaks that fit the screen, using map in Java 8 for transformation and maintainability.

Avoid hard coding by centralizing strings, numbers, and other values into enums or constants to prevent duplication and allow a single change to reflect across multiple classes and environments.

Identify and remove duplicate code by centralizing reusable logic in utility files and validator classes. Collaborate with teammates to refactor, reduce redundancy, and deliver cleaner Java and Python code.

Learn Java best practices by keeping class members private and exposing access through public getters and setters to uphold encapsulation.

Compare string, stringbuilder, and stringbuffer in Java to optimize performance. Recognize that strings are immutable; stringbuilder and stringbuffer are mutable, with stringbuilder faster in non synchronized operations.

Explore how making class members private and exposing them via getters and setters preserves encapsulation, while enabling access auditing and safer data protection in Java.

Learn to optimize string operations by replacing plus concatenation with StringBuilder to avoid intermediate string objects, improving memory use and performance when constructing SQL queries.

use enums to define constants with values and methods to retrieve enums by value, instead of interfaces, which are meant for abstract methods; enums offer flexibility and honor their purpose.

Learn how to use enums as constants in Java, not interfaces, with practical examples of defining day values like Sunday and Monday and using them via getters and setters.

Explore Java loop types and learn to avoid index-based for loops in favor of enhanced for loops or for-each loops to reduce errors when iterating over data.

Learn to choose the right loop in Java, comparing the traditional for loop with the enhanced for loop to safely iterate arrays or lists without index mistakes.

Learn to prevent memory leaks in Java by understanding the JVM garbage collector, avoiding unnecessary object creation, using StringBuilder for strings, and closing resources in finally blocks.

Debug Java applications using built-in and remote tools, including Eclipse and IntelliJ debuggers, breakpoints, and Java Debug Wire Protocol, with JConsole and VisualVM for thread and memory insights.

Learn practical Java debugging in IntelliJ by running a program in debug mode, stepping through main and method calls, evaluating expressions, inspecting a fruit array, and observing console output.

Avoid using multiple if else if statements or nested if else if statements to improve performance; prefer boolean expressions or switch case expressions to reduce cyclomatic complexity in java.

Use primitive data types over object types in java to boost performance by using stack storage and avoiding default initialization, preferring small int, double, and boolean primitives.