{"id":1092,"date":"2025-04-04T09:00:04","date_gmt":"2025-04-04T07:00:04","guid":{"rendered":"https:\/\/chrisengelhard.nl\/teil-6-haufige-anti-patterns-in-der-softwareentwicklung\/"},"modified":"2026-05-04T19:27:32","modified_gmt":"2026-05-04T17:27:32","slug":"teil-6-haufige-anti-patterns-in-der-softwareentwicklung","status":"publish","type":"post","link":"https:\/\/chrisengelhard.nl\/de\/teil-6-haufige-anti-patterns-in-der-softwareentwicklung\/","title":{"rendered":"Teil 6: Haufige Anti-Patterns in der Softwareentwicklung"},"content":{"rendered":"\n

Es gibt verschiedene haufige Anti-Patterns in der Softwareentwicklung, die du vermeiden solltest.<\/p>\n\n

Verwendung von if-else<\/code> fur einen Boolean Return<\/code><\/strong>: 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.<\/p>\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>is_positive<\/span>(<\/span>number<\/span>):<\/span><\/span>\n    <\/span>if<\/span> number <\/span>><\/span> <\/span>0<\/span>:<\/span><\/span>\n        <\/span>return<\/span> <\/span>True<\/span><\/span>\n    <\/span>else<\/span>:<\/span><\/span>\n        <\/span>return<\/span> <\/span>False<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>is_positive<\/span>(<\/span>number<\/span>):<\/span><\/span>\n    <\/span>return<\/span> number <\/span>><\/span> <\/span>0<\/span><\/span><\/code><\/pre><\/div>\n\n
Ubermassige Nutzung von Mutable default arguments<\/code><\/strong>: 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.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>append_to_list<\/span>(<\/span>value<\/span>, <\/span>my_list<\/span>=<\/span>[]):<\/span><\/span>\n    my_list.append(value)<\/span><\/span>\n    <\/span>return<\/span> my_list<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>append_to_list<\/span>(<\/span>value<\/span>, <\/span>my_list<\/span>=<\/span>None<\/span>):<\/span><\/span>\n    <\/span>if<\/span> my_list <\/span>is<\/span> <\/span>None<\/span>:<\/span><\/span>\n        my_list <\/span>=<\/span> []<\/span><\/span>\n    my_list.append(value)<\/span><\/span>\n    <\/span>return<\/span> my_list<\/span><\/span><\/code><\/pre><\/div>\n\n
Ignorieren von Programming idioms<\/code><\/strong>: Das Nichtverwenden idiomatischer Konstrukte, wenn dies angemessen ware. Im guten Beispiel wird eine List Comprehension verwendet, was den Code kurzer und ubersichtlicher macht.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>get_even_numbers<\/span>(<\/span>numbers<\/span>):<\/span><\/span>\n    even_numbers <\/span>=<\/span> []<\/span><\/span>\n    <\/span>for<\/span> number <\/span>in<\/span> numbers:<\/span><\/span>\n        <\/span>if<\/span> number <\/span>%<\/span> <\/span>2<\/span> <\/span>==<\/span> <\/span>0<\/span>:<\/span><\/span>\n            even_numbers.append(number)<\/span><\/span>\n    <\/span>return<\/span> even_numbers<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>get_even_numbers<\/span>(<\/span>numbers<\/span>):<\/span><\/span>\n    <\/span>return<\/span> [number <\/span>for<\/span> number <\/span>in<\/span> numbers <\/span>if<\/span> number <\/span>%<\/span> <\/span>2<\/span> <\/span>==<\/span> <\/span>0<\/span>]<\/span><\/span><\/code><\/pre><\/div>\n\n
Ubermassige Nutzung von Global variables<\/code><\/strong>: 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.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\nglobal_var <\/span>=<\/span> <\/span>10<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>add_to_global<\/span>(<\/span>value<\/span>):<\/span><\/span>\n    <\/span>return<\/span> global_var <\/span>+<\/span> value<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>add_to_value<\/span>(<\/span>value<\/span>, <\/span>base_value<\/span>):<\/span><\/span>\n    <\/span>return<\/span> base_value <\/span>+<\/span> value<\/span><\/span>\n<\/span>\nresult <\/span>=<\/span> add_to_value(<\/span>5<\/span>, <\/span>10<\/span>)  <\/span># Geeft 15 terug<\/span><\/span><\/code><\/pre><\/div>\n\n
Keine Verwendung virtueller Umgebungen<\/strong>: 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.<\/p>\n\n
Schlechtes Beispiel:<\/strong><\/em>Bei der Installation von Paketen ohne virtuelle Umgebung konnen verschiedene Projekte von verschiedenen Versionen derselben Bibliothek abhangen, was zu Konflikten fuhrt.Gutes Beispiel:<\/strong><\/em>Durch die Verwendung einer virtuellen Umgebung, wie z.B. mit venv<\/code> in Python, konnen Abhangigkeiten pro Projekt ohne Konflikte verwaltet werden.<\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
python<\/span> <\/span>-m<\/span> <\/span>venv<\/span> <\/span>myenv<\/span><\/span>\nsource<\/span> <\/span>myenv\/bin\/activate<\/span>  <\/span># Voor Unix-achtige systemen<\/span><\/span>\nmyenv\\Scripts\\activate<\/span>  <\/span># Voor Windows<\/span><\/span>\n<\/span>\npip<\/span> <\/span>install<\/span> <\/span>requests==<\/span>2.25<\/span>.1<\/span>  <\/span># Installeert alleen in de virtuele omgeving<\/span><\/span><\/code><\/pre><\/div>\n\n
God Object<\/strong>: Dies bezieht sich auf ein Objekt, das zu viele Verantwortlichkeiten hat und dadurch schwer zu verstehen und zu warten ist.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\nclass<\/span> <\/span>Application<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.database <\/span>=<\/span> Database()<\/span><\/span>\n        <\/span>self<\/span>.user_interface <\/span>=<\/span> UserInterface()<\/span><\/span>\n        <\/span>self<\/span>.network <\/span>=<\/span> Network()<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>run<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.database.connect()<\/span><\/span>\n        <\/span>self<\/span>.user_interface.display()<\/span><\/span>\n        <\/span>self<\/span>.network.fetch_data()<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\nclass<\/span> <\/span>Application<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>, <\/span>database<\/span>, <\/span>user_interface<\/span>, <\/span>network<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.database <\/span>=<\/span> database<\/span><\/span>\n        <\/span>self<\/span>.user_interface <\/span>=<\/span> user_interface<\/span><\/span>\n        <\/span>self<\/span>.network <\/span>=<\/span> network<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>run<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.database.connect()<\/span><\/span>\n        <\/span>self<\/span>.user_interface.display()<\/span><\/span>\n        <\/span>self<\/span>.network.fetch_data()<\/span><\/span>\n<\/span>\napp <\/span>=<\/span> Application(Database(), UserInterface(), Network())<\/span><\/span>\napp.run()<\/span><\/span><\/code><\/pre><\/div>\n\n
Spaghetti-Code<\/strong>: Dies ist ein Begriff, der verwendet wird, um Code zu beschreiben, der schlecht strukturiert und schwer zu verfolgen ist.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>process_data<\/span>(<\/span>data<\/span>):<\/span><\/span>\n    <\/span>if<\/span> data:<\/span><\/span>\n        <\/span>for<\/span> item <\/span>in<\/span> data:<\/span><\/span>\n            <\/span>if<\/span> item[<\/span>'<\/span>status<\/span>'<\/span>] <\/span>==<\/span> <\/span>'<\/span>active<\/span>'<\/span>:<\/span><\/span>\n                <\/span>print<\/span>(item[<\/span>'<\/span>name<\/span>'<\/span>])<\/span><\/span>\n            <\/span>else<\/span>:<\/span><\/span>\n                <\/span>if<\/span> item[<\/span>'<\/span>status<\/span>'<\/span>] <\/span>==<\/span> <\/span>'<\/span>inactive<\/span>'<\/span>:<\/span><\/span>\n                    <\/span>print<\/span>(item[<\/span>'<\/span>name<\/span>'<\/span>] <\/span>+<\/span> <\/span>"<\/span> is inactive<\/span>"<\/span>)<\/span><\/span>\n                <\/span>else<\/span>:<\/span><\/span>\n                    <\/span>print<\/span>(<\/span>"<\/span>Unknown status<\/span>"<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>process_data<\/span>(<\/span>data<\/span>):<\/span><\/span>\n    <\/span>for<\/span> item <\/span>in<\/span> data:<\/span><\/span>\n        handle_item(item)<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>handle_item<\/span>(<\/span>item<\/span>):<\/span><\/span>\n    <\/span>if<\/span> item[<\/span>'<\/span>status<\/span>'<\/span>] <\/span>==<\/span> <\/span>'<\/span>active<\/span>'<\/span>:<\/span><\/span>\n        <\/span>print<\/span>(item[<\/span>'<\/span>name<\/span>'<\/span>])<\/span><\/span>\n    <\/span>elif<\/span> item[<\/span>'<\/span>status<\/span>'<\/span>] <\/span>==<\/span> <\/span>'<\/span>inactive<\/span>'<\/span>:<\/span><\/span>\n        <\/span>print<\/span>(item[<\/span>'<\/span>name<\/span>'<\/span>] <\/span>+<\/span> <\/span>"<\/span> is inactive<\/span>"<\/span>)<\/span><\/span>\n    <\/span>else<\/span>:<\/span><\/span>\n        <\/span>print<\/span>(<\/span>"<\/span>Unknown status<\/span>"<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n
Copy-Paste-Programmierung<\/strong>: Das Wiederholen von Code durch Kopieren und Einfugen anstatt wiederverwendbare Funktionen oder Module zu erstellen.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>calculate_area_circle<\/span>(<\/span>radius<\/span>):<\/span><\/span>\n    <\/span>return<\/span> <\/span>3.14<\/span> <\/span>*<\/span> radius <\/span>*<\/span> radius<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>calculate_area_square<\/span>(<\/span>side<\/span>):<\/span><\/span>\n    <\/span>return<\/span> side <\/span>*<\/span> side<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>calculate_area_rectangle<\/span>(<\/span>length<\/span>, <\/span>width<\/span>):<\/span><\/span>\n    <\/span>return<\/span> length <\/span>*<\/span> width<\/span><\/span>\n<\/span>\n# Herhaling van de formule voor cirkel<\/span><\/span>\ndef<\/span> <\/span>calculate_area_circle_v2<\/span>(<\/span>radius<\/span>):<\/span><\/span>\n    <\/span>return<\/span> <\/span>3.14<\/span> <\/span>*<\/span> radius <\/span>*<\/span> radius<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>calculate_area_circle<\/span>(<\/span>radius<\/span>):<\/span><\/span>\n    <\/span>return<\/span> <\/span>3.14<\/span> <\/span>*<\/span> radius <\/span>*<\/span> radius<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>calculate_area_square<\/span>(<\/span>side<\/span>):<\/span><\/span>\n    <\/span>return<\/span> side <\/span>*<\/span> side<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>calculate_area_rectangle<\/span>(<\/span>length<\/span>, <\/span>width<\/span>):<\/span><\/span>\n    <\/span>return<\/span> length <\/span>*<\/span> width<\/span><\/span>\n<\/span>\n# Herbruikbare functie voor cirkel<\/span><\/span>\ndef<\/span> <\/span>calculate_area_circle_v2<\/span>(<\/span>radius<\/span>):<\/span><\/span>\n    <\/span>return<\/span> calculate_area_circle(radius)<\/span><\/span><\/code><\/pre><\/div>\n\n
Magic Numbers<\/strong>: Die Verwendung unklarer konstanter Werte im Code ohne Erklarung oder Kontext.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>calculate_discount<\/span>(<\/span>price<\/span>):<\/span><\/span>\n    <\/span>return<\/span> price <\/span>*<\/span> <\/span>0.2<\/span>  <\/span># 20% korting<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\nDISCOUNT_RATE<\/span> <\/span>=<\/span> <\/span>0.2<\/span><\/span>\n<\/span>\ndef<\/span> <\/span>calculate_discount<\/span>(<\/span>price<\/span>):<\/span><\/span>\n    <\/span>return<\/span> price <\/span>*<\/span> <\/span>DISCOUNT_RATE<\/span><\/span><\/code><\/pre><\/div>\n\n
Over-Engineering<\/strong>: Das Erstellen einer zu komplexen Losung fur ein einfaches Problem.<\/p>\n\n
Schlechtes Beispiel:<\/em><\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\nclass<\/span> <\/span>ComplexCalculator<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>add<\/span>(<\/span>self<\/span>, <\/span>a<\/span>, <\/span>b<\/span>):<\/span><\/span>\n        <\/span>return<\/span> a <\/span>+<\/span> b<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>subtract<\/span>(<\/span>self<\/span>, <\/span>a<\/span>, <\/span>b<\/span>):<\/span><\/span>\n        <\/span>return<\/span> a <\/span>-<\/span> b<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>multiply<\/span>(<\/span>self<\/span>, <\/span>a<\/span>, <\/span>b<\/span>):<\/span><\/span>\n        <\/span>return<\/span> a <\/span>*<\/span> b<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>divide<\/span>(<\/span>self<\/span>, <\/span>a<\/span>, <\/span>b<\/span>):<\/span><\/span>\n        <\/span>return<\/span> a <\/span>\/<\/span> b<\/span><\/span>\n<\/span>\n# Te veel complexiteit voor eenvoudige berekeningen<\/span><\/span>\ncalc <\/span>=<\/span> ComplexCalculator()<\/span><\/span>\nresult <\/span>=<\/span> calc.add(<\/span>5<\/span>, <\/span>3<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>add<\/span>(<\/span>a<\/span>, <\/span>b<\/span>):<\/span><\/span>\n    <\/span>return<\/span> a <\/span>+<\/span> b<\/span><\/span>\n<\/span>\nresult <\/span>=<\/span> add(<\/span>5<\/span>, <\/span>3<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n
Not Invented Here (NIH)<\/strong>: Die Neigung, bestehende Losungen oder Bibliotheken zu ignorieren und stattdessen selbst etwas zu bauen.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\nclass<\/span> <\/span>CustomList<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.items <\/span>=<\/span> []<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>add<\/span>(<\/span>self<\/span>, <\/span>item<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.items.append(item)<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>get<\/span>(<\/span>self<\/span>, <\/span>index<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>self<\/span>.items[index]<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\nmy_list <\/span>=<\/span> []<\/span><\/span>\nmy_list.append(<\/span>"<\/span>item<\/span>"<\/span>)<\/span><\/span>\nprint<\/span>(my_list[<\/span>0<\/span>])<\/span><\/span><\/code><\/pre><\/div>\n\n
Premature Optimization<\/strong>: Das Optimieren von Code, bevor es notwendig ist.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>calculate_sum<\/span>(<\/span>numbers<\/span>):<\/span><\/span>\n    total <\/span>=<\/span> <\/span>0<\/span><\/span>\n    <\/span>for<\/span> number <\/span>in<\/span> numbers:<\/span><\/span>\n        total <\/span>+=<\/span> number<\/span><\/span>\n    <\/span>return<\/span> total<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>calculate_sum<\/span>(<\/span>numbers<\/span>):<\/span><\/span>\n    <\/span>return<\/span> <\/span>sum<\/span>(numbers)<\/span><\/span><\/code><\/pre><\/div>\n\n
Hardcoding<\/strong>: Das direkte Einbetten von Werten in den Code, die besser extern verwaltet werden sollten.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>connect_to_database<\/span>():<\/span><\/span>\n    connection <\/span>=<\/span> create_connection(<\/span>"<\/span>localhost<\/span>"<\/span>, <\/span>"<\/span>root<\/span>"<\/span>, <\/span>"<\/span>password<\/span>"<\/span>, <\/span>"<\/span>my_database<\/span>"<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>connect_to_database<\/span>(<\/span>host<\/span>, <\/span>user<\/span>, <\/span>password<\/span>, <\/span>database<\/span>):<\/span><\/span>\n    connection <\/span>=<\/span> create_connection(host, user, password, database)<\/span><\/span>\n<\/span>\n# Gebruik van variabelen of configuratiebestanden<\/span><\/span>\nconnect_to_database(<\/span>"<\/span>localhost<\/span>"<\/span>, <\/span>"<\/span>root<\/span>"<\/span>, <\/span>"<\/span>password<\/span>"<\/span>, <\/span>"<\/span>my_database<\/span>"<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n
Mangelnde Kohasion<\/strong>: Eine Situation, in der ein Modul oder eine Klasse Verantwortlichkeiten hat, die nicht logisch miteinander verbunden sind.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\nclass<\/span> <\/span>Utility<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>calculate_area_circle<\/span>(<\/span>self<\/span>, <\/span>radius<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>3.14<\/span> <\/span>*<\/span> radius <\/span>*<\/span> radius<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>print_message<\/span>(<\/span>self<\/span>, <\/span>message<\/span>):<\/span><\/span>\n        <\/span>print<\/span>(message)<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\nclass<\/span> <\/span>Circle<\/span>:<\/span><\/span>\n    <\/span>def<\/span> <\/span>__init__<\/span>(<\/span>self<\/span>, <\/span>radius<\/span>):<\/span><\/span>\n        <\/span>self<\/span>.radius <\/span>=<\/span> radius<\/span><\/span>\n<\/span>\n    <\/span>def<\/span> <\/span>area<\/span>(<\/span>self<\/span>):<\/span><\/span>\n        <\/span>return<\/span> <\/span>3.14<\/span> <\/span>*<\/span> <\/span>self<\/span>.radius <\/span>*<\/span> <\/span>self<\/span>.radius<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>MessagePrinter<\/span>:<\/span><\/span>\n    <\/span>@<\/span>staticmethod<\/span><\/span>\n    <\/span>def<\/span> <\/span>print_message<\/span>(<\/span>message<\/span>):<\/span><\/span>\n        <\/span>print<\/span>(message)<\/span><\/span><\/code><\/pre><\/div>\n\n
Ubermassige Abhangigkeit von Kommentaren<\/strong>: Das Schreiben von unklarem oder komplexem Code und das anschliessende Verlassen auf Kommentare, um die Logik zu erklaren.<\/p>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Slecht voorbeeld<\/span><\/span>\ndef<\/span> <\/span>calculate_discount<\/span>(<\/span>price<\/span>):<\/span><\/span>\n    <\/span># Deze functie berekent de korting<\/span><\/span>\n    <\/span>return<\/span> price <\/span>*<\/span> <\/span>0.2<\/span>  <\/span># 20% korting<\/span><\/span><\/code><\/pre><\/div>\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
# Goed voorbeeld<\/span><\/span>\ndef<\/span> <\/span>calculate_discount<\/span>(<\/span>price<\/span>, <\/span>discount_rate<\/span>=<\/span>0.2<\/span>):<\/span><\/span>\n    <\/span>return<\/span> price <\/span>*<\/span> discount_rate<\/span><\/span><\/code><\/pre><\/div>\n\n
Hast du Fragen oder Anmerkungen? Lass es mich wissen!<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
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. Ubermassige Nutzung von Mutable default arguments: Die Verwendung von […]<\/p>\n","protected":false},"author":2,"featured_media":923,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_gspb_post_css":".gspb_text-id-gsbp-1e09893{margin-top:1.5rem!important;margin-bottom:1.5rem!important;padding-left:1.5rem!important}","footnotes":""},"categories":[50,73,51],"tags":[27,25,26,29],"class_list":["post-1092","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-softwareentwicklung","category-best-practices","category-programmierung","tag-anti-patronen","tag-codekwaliteit","tag-ontwerpprincipes","tag-serie"],"_links":{"self":[{"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/posts\/1092","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/comments?post=1092"}],"version-history":[{"count":11,"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/posts\/1092\/revisions"}],"predecessor-version":[{"id":1476,"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/posts\/1092\/revisions\/1476"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/media\/923"}],"wp:attachment":[{"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/media?parent=1092"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/categories?post=1092"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/chrisengelhard.nl\/de\/wp-json\/wp\/v2\/tags?post=1092"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}