Anti pattern ký

What is Anti-pattern ( and why should I care)?

Why are Antipattern so pervasive?

Patterns are abstractions of experiences

Anti patterns are more difficult to draft, but rapidly lead to sharing of experiences

Development Anti pattern

🍝 Spaghetti code

• Un-structured code is a liability

• Well structured code is an assess

Common Symptoms:

• quick demonstrate on code that became operational

• ‘Lone Ranger’ programmer?

• Obsolete or scanty documentation

• 50% of maintenance spent on system rediscovery

• Hesitant programmer syndrome
• More likely to break it than extend it
• Easier to just rewire it

• Cannot be reused
• System software and COST packages can’t be upgraded
• performance continue be optimized

• User work arounds

OOP symptoms:

• Many object methods with no parameters.

• Suspicions class or global variables

• interwind and unforeseen relationships between objects

• process-oriented method, object with process-oriented names.

• OO advantage lost - inheritance cannot be used to extend the system, polymorphism not effective either.

OOP symptoms and strategy: 🧑‍💼Reform the software process

• Refactoring as your program (Beck 1996)
• Incremental development
• refactoring to move structure
• incremental test
• iterate

• Use programming discipline (Humphrey 1995)
• keep track of defects (metrics)
• learn to avoid programming defects

• Use Architecture-Centred development (Booch 1996)
• define enforceable system boundaries
• use design pattern to document software

• Refactor to generalize: create an abstract superclass:

• Refactor to specialize: Simplify conditionals

• Refactor to combine: capture aggregations and components

References: Spaghetti Code (sourcemaking.com)

The Blob ( or 🧔‍♀️God class)

OOP symptoms:

• Single class with many attribute and operations. ( >60 attributes)

• Controller class with simple, data object classes

• Lack of OO design

• A migrated legacy design

Use case: Reeo

From last year we had a MVP project and must get it done in 😨 5 week. Struggles in early weeks with a ton of business things. We had no time to build a neatly product. So we have no choice to accepted Anti pattern Blob. After first release, we wanted to add more features and nightmare was coming!

Main file: blob-example (github.com)

👻 Poltergeists ( the opposite of the 🧔‍♀️God class)

OOP symptoms:

• Redundant navigation paths.

• Transient associations.

• Stateless classes.

• Temporary, short-duration objects and classes.

• Excessive complexity

• Unstable analysis and design models.

• Poor system performance

• Lack of system extensibility

• Refactor to eliminate irrelevant classes:
• Delete external classes
• Delete classes with no domain relevance

• Refactor to eliminate transient “data classes”

• Refactor to eliminate “Operation classes”

• Refactor other classes with short life cycles or few responsibilities
• Mote into collaborating classed
• Regroup into cohesive larger classes

public class EngineerManager
{
    private Delivery delivery;
 
    public EngineerManager(Delivery delivery)
    {
        this.delivery= delivery;
    }
 
    public void DeliveryWebFeature()
    {
        delivery.deliveryWebFeature();
    }
		
    public void DeliveryMobileFeature()
    {
        delivery.deliveryMobileFeature();
    }
}

<?php

class OrderController
{
    public function payOrder($orderId)
    {
        if(isset($_POST['Order'])) {
            $order = Order::findOrFail($orderId);
            $invoice = new Invoice();
            $invoice->setOrder($order);
            $invoice->setUser(Auth::user());

            if($invoice->save()) {
                $email = new Email();
                $email->setSubject('Invoice for order#' . $order->id);

                // ...

                if($email->send()) {
                    $this->redirectTo('orders');
                } else {
                    // ... fail
                }
            } else {
                // ... fail
            }
        }
    }
}

<?php

class InvoicePaymentHandler
{
    public function make(array $data)
    {
        $order = Order::findOrFail($orderId);
        $invoice = new Invoice();
        $invoice->setOrder($order);
        $invoice->setUser(Auth::user());

        if($invoice->save()) {
            $email = new Email();
            $email->setSubject('Invoice for order#' . $order->id);
            ...

            return $email->send();
        } 

        return false;
    }
}

<?php

class OrderController
{
    public function payOrder($orderId)
    {
        if($_POST['Order']) {
            $invoicePayment = new InvoicePaymentHandler();
            if($invoicePayment->make($_POST['Order'])) {
                $this->redirectTo('orders');
            }
            
            $errors = $invoicePayment->getErrors();
            $this->redirectBack($errors);
        }
    }
}

<?php

class OrderController
{
    public function payOrder($orderId)
    {
        if($_POST['Order']) {
            $order = Order::findOrFail($orderId);

            try {
                $order->makeInvoice(
                    $_POST['Order'], Auth::user()
                );
            } catch(InvoiceCreationException $e) {
                $this->redirectBack(
                    $e->getMessage()
                );
            }

            $this->redirectTo('orders');
        }
    }
}

Mini Antipattern ( Is coming..)