Teil 6: Haufige Anti-Patterns In Der Softwareentwicklung

Es gibt verschiedene haufige Anti-Patterns in der Softwareentwicklung, die du vermeiden solltest.

Verwendung von if-else fur einen Boolean Return: Das Schreiben uberflussiger bedingter Anweisungen anstatt den Booleschen Ausdruck direkt zuruckzugeben. Im guten Beispiel wird der Boolesche Ausdruck direkt zuruckgegeben, was den Code einfacher und lesbarer macht.

# Slecht voorbeeld
def is_positive(number):
    if number > 0:
        return True
    else:
        return False

# Goed voorbeeld
def is_positive(number):
    return number > 0

Ubermassige Nutzung von Mutable default arguments: Die Verwendung von veranderlichen Standardargumenten kann zu unerwartetem Verhalten fuhren. Im guten Beispiel wird eine neue Liste erstellt, wenn keine Liste ubergeben wird. Dies verhindert, dass die Standardliste zwischen Funktionsaufrufen geteilt wird.

# Slecht voorbeeld
def append_to_list(value, my_list=[]):
    my_list.append(value)
    return my_list

# Goed voorbeeld
def append_to_list(value, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(value)
    return my_list

Ignorieren von Programming idioms: Das Nichtverwenden idiomatischer Konstrukte, wenn dies angemessen ware. Im guten Beispiel wird eine List Comprehension verwendet, was den Code kurzer und ubersichtlicher macht.

# Slecht voorbeeld
def get_even_numbers(numbers):
    even_numbers = []
    for number in numbers:
        if number % 2 == 0:
            even_numbers.append(number)
    return even_numbers

# Goed voorbeeld
def get_even_numbers(numbers):
    return [number for number in numbers if number % 2 == 0]

Ubermassige Nutzung von Global variables: Das Verlassen auf globale Variablen anstatt Daten uber Funktionsargumente oder Klassenattribute zu ubergeben. Im guten Beispiel wird der Wert als Argument ubergeben, was die Funktion flexibler und besser testbar macht.

# Slecht voorbeeld
global_var = 10

def add_to_global(value):
    return global_var + value

# Goed voorbeeld
def add_to_value(value, base_value):
    return base_value + value

result = add_to_value(5, 10)  # Geeft 15 terug

Keine Verwendung virtueller Umgebungen: Das Nichtisolieren von Projektabhangigkeiten kann zu Abhangigkeitskonflikten fuhren. Im guten Beispiel wird eine virtuelle Umgebung erstellt und aktiviert. Dies sorgt fur eine saubere und isolierte Umgebung fur das Projekt und verhindert, dass sich Abhangigkeiten verschiedener Projekte gegenseitig beeinflussen.

Schlechtes Beispiel:
Bei der Installation von Paketen ohne virtuelle Umgebung konnen verschiedene Projekte von verschiedenen Versionen derselben Bibliothek abhangen, was zu Konflikten fuhrt.

Gutes Beispiel:
Durch die Verwendung einer virtuellen Umgebung, wie z.B. mit venv in Python, konnen Abhangigkeiten pro Projekt ohne Konflikte verwaltet werden.

python -m venv myenv
source myenv/bin/activate  # Voor Unix-achtige systemen
myenv\Scripts\activate  # Voor Windows

pip install requests==2.25.1  # Installeert alleen in de virtuele omgeving

God Object: Dies bezieht sich auf ein Objekt, das zu viele Verantwortlichkeiten hat und dadurch schwer zu verstehen und zu warten ist.

# Slecht voorbeeld
class Application:
    def __init__(self):
        self.database = Database()
        self.user_interface = UserInterface()
        self.network = Network()

    def run(self):
        self.database.connect()
        self.user_interface.display()
        self.network.fetch_data()

# Goed voorbeeld
class Application:
    def __init__(self, database, user_interface, network):
        self.database = database
        self.user_interface = user_interface
        self.network = network

    def run(self):
        self.database.connect()
        self.user_interface.display()
        self.network.fetch_data()

app = Application(Database(), UserInterface(), Network())
app.run()

Spaghetti-Code: Dies ist ein Begriff, der verwendet wird, um Code zu beschreiben, der schlecht strukturiert und schwer zu verfolgen ist.

# Slecht voorbeeld
def process_data(data):
    if data:
        for item in data:
            if item['status'] == 'active':
                print(item['name'])
            else:
                if item['status'] == 'inactive':
                    print(item['name'] + " is inactive")
                else:
                    print("Unknown status")

# Goed voorbeeld
def process_data(data):
    for item in data:
        handle_item(item)

def handle_item(item):
    if item['status'] == 'active':
        print(item['name'])
    elif item['status'] == 'inactive':
        print(item['name'] + " is inactive")
    else:
        print("Unknown status")

Copy-Paste-Programmierung: Das Wiederholen von Code durch Kopieren und Einfugen anstatt wiederverwendbare Funktionen oder Module zu erstellen.

# Slecht voorbeeld
def calculate_area_circle(radius):
    return 3.14 * radius * radius

def calculate_area_square(side):
    return side * side

def calculate_area_rectangle(length, width):
    return length * width

# Herhaling van de formule voor cirkel
def calculate_area_circle_v2(radius):
    return 3.14 * radius * radius

# Goed voorbeeld
def calculate_area_circle(radius):
    return 3.14 * radius * radius

def calculate_area_square(side):
    return side * side

def calculate_area_rectangle(length, width):
    return length * width

# Herbruikbare functie voor cirkel
def calculate_area_circle_v2(radius):
    return calculate_area_circle(radius)

Magic Numbers: Die Verwendung unklarer konstanter Werte im Code ohne Erklarung oder Kontext.

# Slecht voorbeeld
def calculate_discount(price):
    return price * 0.2  # 20% korting

# Goed voorbeeld
DISCOUNT_RATE = 0.2

def calculate_discount(price):
    return price * DISCOUNT_RATE

Over-Engineering: Das Erstellen einer zu komplexen Losung fur ein einfaches Problem.

Schlechtes Beispiel:

# Slecht voorbeeld
class ComplexCalculator:
    def add(self, a, b):
        return a + b

    def subtract(self, a, b):
        return a - b

    def multiply(self, a, b):
        return a * b

    def divide(self, a, b):
        return a / b

# Te veel complexiteit voor eenvoudige berekeningen
calc = ComplexCalculator()
result = calc.add(5, 3)

# Goed voorbeeld
def add(a, b):
    return a + b

result = add(5, 3)

Not Invented Here (NIH): Die Neigung, bestehende Losungen oder Bibliotheken zu ignorieren und stattdessen selbst etwas zu bauen.

# Slecht voorbeeld
class CustomList:
    def __init__(self):
        self.items = []

    def add(self, item):
        self.items.append(item)

    def get(self, index):
        return self.items[index]

# Goed voorbeeld
my_list = []
my_list.append("item")
print(my_list[0])

Premature Optimization: Das Optimieren von Code, bevor es notwendig ist.

# Slecht voorbeeld
def calculate_sum(numbers):
    total = 0
    for number in numbers:
        total += number
    return total

# Goed voorbeeld
def calculate_sum(numbers):
    return sum(numbers)

Hardcoding: Das direkte Einbetten von Werten in den Code, die besser extern verwaltet werden sollten.

# Goed voorbeeld
def connect_to_database():
    connection = create_connection("localhost", "root", "password", "my_database")

# Goed voorbeeld
def connect_to_database(host, user, password, database):
    connection = create_connection(host, user, password, database)

# Gebruik van variabelen of configuratiebestanden
connect_to_database("localhost", "root", "password", "my_database")

Mangelnde Kohasion: Eine Situation, in der ein Modul oder eine Klasse Verantwortlichkeiten hat, die nicht logisch miteinander verbunden sind.

# Slecht voorbeeld
class Utility:
    def calculate_area_circle(self, radius):
        return 3.14 * radius * radius

    def print_message(self, message):
        print(message)

# Goed voorbeeld
class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class MessagePrinter:
    @staticmethod
    def print_message(message):
        print(message)

Ubermassige Abhangigkeit von Kommentaren: Das Schreiben von unklarem oder komplexem Code und das anschliessende Verlassen auf Kommentare, um die Logik zu erklaren.

# Slecht voorbeeld
def calculate_discount(price):
    # Deze functie berekent de korting
    return price * 0.2  # 20% korting

# Goed voorbeeld
def calculate_discount(price, discount_rate=0.2):
    return price * discount_rate

Hast du Fragen oder Anmerkungen? Lass es mich wissen!

Teil 6: Haufige Anti-Patterns in der Softwareentwicklung