Skip to main content

Software Engineering Principles: DRY, KISS, and YAGNI

Software Engineering Principles: DRY, KISS, and YAGNI

Software Engineering Principles: DRY, KISS, and YAGNI

DRY (Don't Repeat Yourself)

Principle: The DRY principle emphasizes the importance of reducing repetition within code. Repetition can lead to more errors, higher maintenance costs, and inconsistency. When the same piece of code or logic appears in multiple places, it should be abstracted out into a single location that can be reused.

Example:

Without DRY:


public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public double divide(int a, int b) {
        return a / b;
    }

    public int addAndSubtract(int a, int b, int c) {
        return a + b - c; // repeated addition and subtraction logic
    }
}

With DRY:


public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public double divide(int a, int b) {
        return a / b;
    }

    public int addAndSubtract(int a, int b, int c) {
        return subtract(add(a, b), c); // reuse add and subtract methods
    }
}

KISS (Keep It Simple, Stupid)

Principle: The KISS principle advocates for simplicity in design and implementation. The idea is to avoid unnecessary complexity, making code easier to understand, maintain, and debug.

Example:

Without KISS:


public class OrderProcessor {
    public void processOrder(Order order) {
        if (order != null && order.getItems() != null 
               && !order.getItems().isEmpty() 
               && order.getCustomer() != null) {
            // complex processing logic
            for (Item item : order.getItems()) {
                // process each item
            }
        } else {
            // handle invalid order
        }
    }
}

With KISS:


public class OrderProcessor {
    public void processOrder(Order order) {
        if (!isValidOrder(order)) {
            // handle invalid order
            return;
        }
        // simple processing logic
        for (Item item : order.getItems()) {
            // process each item
        }
    }

    private boolean isValidOrder(Order order) {
        return order != null && order.getItems() != null 
                    && !order.getItems().isEmpty() 
                              && order.getCustomer() != null;
    }
}

YAGNI (You Aren't Gonna Need It)

Principle: YAGNI encourages developers to avoid adding functionality until it is necessary. This helps in reducing the complexity and avoiding wasted effort on features that may never be used.

Example:

Without YAGNI:


public class UserManager {
    public void createUser(String username, String password) {
        // create user
    }

    public void createUser(String username, 
           String password, String email, 
           String phoneNumber, String address) {
        // create user with additional details
    }
}

With YAGNI:


public class UserManager {
    public void createUser(String username, String password) {
        // create user
    }
}

Summary

  • DRY (Don't Repeat Yourself): Avoid duplication of code by abstracting repeated logic into reusable methods or components.
  • KISS (Keep It Simple, Stupid): Keep code simple and straightforward to make it more understandable and maintainable.
  • YAGNI (You Aren't Gonna Need It): Do not add functionality until it is necessary, preventing unnecessary complexity.

These principles collectively help in writing clean, maintainable, and efficient code.

Labels:

Comments

Post a Comment

Popular posts from this blog

Understanding C1 and C2 Compilers in Java

Understanding C1 and C2 Compilers in Java Understanding C1 and C2 Compilers in Java In Java, the Just-In-Time (JIT) compiler is a part of the Java Virtual Machine (JVM) that improves the performance of Java applications by compiling bytecode into native machine code at runtime. The JIT compiler includes two different compilers, known as the C1 and C2 compilers, each with distinct optimization strategies and purposes. C1 Compiler (Client Compiler) The C1 compiler, also known as the client compiler, is designed for fast startup times and lower memory consumption. It performs lighter and quicker optimizations, which makes it suitable for applications that require quick startup and responsiveness. Key characteristics of the C1 compiler include: Quick Compilation: Prioritizes fast compilation times over deep optimizations. Low Overhead: Consumes less memory and resources during compilation. Profile-Guided Optimization: Ca...
Post a Comment
Read more

Java Increment Operations: `n++` vs `n = n + 1` vs `n += 1`

In Java, incrementing a variable by one can be done in several ways: n++ , n = n + 1 , and n += 1 . While these expressions achieve the same end result, they differ slightly in syntax and use cases. Let's explore each one and discuss their performance. 1. n++ Post-Increment Operator : Increments the value of n by 1 after its current value has been used. Common Usage : Typically used in loops and other contexts where the current value needs to be used before incrementing. int n = 5; n++; // n is now 6 2. n = n + 1 Addition Assignment : Explicitly sets n to its current value plus 1. Readability : Straightforward and clear, though slightly more verbose. int n = 5; n = n + 1; // n is now 6 3. n += 1 Compound Assignment Operator : Equivalent to n = n + 1 , but more concise. Usage : Combines addition and assignment into one step. int n = 5; n += 1; // n is...
Post a Comment
Read more

How to use WSO2 Class Mediator in WSO2 ESB

The  Class Mediator  creates an instance of a custom-specified class and sets it as a mediator. If any properties are specified, the corresponding setter methods are invoked once on the class during initialization. Use the Class mediator for user-specific, custom developments only when there is no built-in mediator that already provides the required functionality.  The syntax of Class Mediator in ESB < class   name= "class-name" >     <property name= "string"   value= "literal" >     </property> </ class > Creating a Class Mediator lets use the Eclipse  WSO2 Developer Studio Create a New  Mediator project by selecting File --> New --> project --> Mediator Project Now you have class mediator by extending the AbstractMediator class. Then you need to implement the mediate methods Sample class mediator implementation is as follows. package ...
Post a Comment
Read more