Motivation für sauberen Code

Mar 13 2023

Unabhängig vom Umfang des Softwareprojekts müssen wir Teil jedes Teams sein, ob groß oder klein. Daher ist es sehr wichtig, dass der von uns geschriebene Code für andere Entwickler lesbar und entwickelbar sein sollte.

Die Programmierkunst von Geek & Poke ist unter CC BY 3.0 lizenziert

„Big“ Dave Thomas (Gründer von OTI, dem Paten der Eclipse-Strategie) definiert sauberen Code mit diesen Sätzen:

Sauberer Code kann von einem anderen Entwickler als seinem ursprünglichen Autor gelesen und verbessert werden . Es verfügt über Unit- und Abnahmetests. Es hat aussagekräftige Namen. Es bietet eine Möglichkeit und nicht viele Möglichkeiten, eine Sache zu tun. Es verfügt über minimale Abhängigkeiten, die explizit definiert sind, und bietet eine klare und minimale API.

Andererseits müssen wir, selbst wenn wir das Projekt alleine weiterführen, Monate oder Jahre später möglicherweise zusätzliche Entwicklungen für jedes Modul des Projekts vornehmen. Es ist notwendig, auf einen Blick zu verstehen, welche Aufgabe der vor Jahren geschriebene Code erfüllt, welche Module des Projekts er bedient, um die psychische Gesundheit des Entwicklers zu schützen und sicherzustellen, dass andere Module davon nicht betroffen sind die Neuentwicklung.

Jeder Dummkopf kann Code schreiben, den ein Computer verstehen kann. Gute Programmierer schreiben Code, den Menschen verstehen können. Martin Fowler

Warum ist sauberer Code erforderlich?

Es ist nicht schwer vorherzusagen, was passieren wird, wenn mit unsauberem Code entwickelt wird. Ich möchte über einige der Probleme sprechen, mit denen wir konfrontiert werden.

Wenn der Code nicht sauber ist;

Erzeugt technische Schulden (Wenn Sie einen Blick darauf werfen möchten: „https://en.wikipedia.org/wiki/Technical_debt“). Wir können über die Verwaltung technischer Schulden unter einer anderen Überschrift sprechen, aber es kann viele Gründe für technische Schulden geben. Der erste Zünder dieses Dochtes ist ebenfalls nicht sauber kodiert.
Wir stoßen auf Codeblöcke, die nicht mehr wartbar sind. Mit der Zeit kann es auch sein, dass das Projekt nicht mehr wartbar ist.
Wäre für die Entwicklung kostspielig. Die Entwicklungskosten wären höher als sie sein sollten. Wenn das Entwicklerteam die Kosten nicht vorhersehen kann, ist das ein klarer Hinweis darauf, dass wir ein Projekt haben, das nicht sauber entwickelt wurde.
Die Verwirrung wächst. Mit jeder hinzugefügten Funktion, jedem entwickelten Codeblock wird die Verwirrung größer. Dies bedeutet, dass das Projekt mit der Zeit stirbt. Sie haben vielleicht schon oft gehört: „Lass uns das umschreiben.“

Zunächst brauchen wir das Bewusstsein aller Teammitglieder und der Institution, die das Projekt betreibt. Weil es Zeit kostet, sauberen Code zu erreichen. (Geld kostet natürlich, Zeit = Geld)

Wir müssen die Motivation haben, Programmierung und Refactoring mit anderen Teammitgliedern zu koordinieren.

Wir müssen weiter mit den technischen und kommerziellen Teams kommunizieren, um sicherzustellen, dass wir das Modul oder den Codeblock einfach erklären und besprechen können.

Sauberes Codieren ist keine Fähigkeit, die man über Nacht erwerben kann. Es ist eine Gewohnheit, die entwickelt werden muss, indem man diese Prinzipien im Hinterkopf behält und sie beim Schreiben von Code anwendet. Yiğit Kemal Erinç

Coderahmen bereinigen

Einfach, fokussiert, Vollständigkeit, Korrektheit.

Damit wir akzeptieren, dass die Clean-Code-Prinzipien befolgt werden;

Der Code sollte einfach und verständlich sein.
Funktionen, Klassen und Variablen sollten im Fokus stehen . Sie sollten allein verantwortlich sein und keine Nebenwirkungen haben.
Es sollte auf alle Bedürfnisse eingehen können , mögliche Fälle abdecken, die Entwicklung ermöglichen und Situationen verhindern, die vermieden werden sollten.
Wir müssen sicherstellen, dass es richtig funktioniert . Dies ist nur mit Unit- und Abnahmetests möglich. Zum Testen von Integrationen sind Integrationstests erforderlich.

Der Name einer Variablen, Funktion oder Klasse sollte alle wichtigen Fragen beantworten. Es sollte Ihnen sagen, warum es existiert, was es tut und wie es verwendet wird. Wenn ein Name einen Kommentar erfordert, verrät der Name nicht seine Absicht. Robert C. Martin

public List<string> GetTags(int[] a)
{
  var list = new List<string>();
  
  for (var b = 0; b < theList.Count; b++)
  {
    if (theList[b].CityCodes.Intersect(a).Any())
    {
      list.Add(theList[b].TagName);
     }
   }

   return list;
}

Ohne einen Kommentar oder ein tiefes Eintauchen in den Code ist es mir unmöglich zu verstehen, welchen Zweck diese Methode und Parameter erfüllen. Wenn ich an dieser Stelle die Benennung unter der Bedingung bearbeite, dass sie in dem Kontext, in dem ich sie entwickle, sinnvoll ist, nähere ich mich einem saubereren Code. Lass es uns tun.

public List<string> GetTagNamesThatMatchedCityCodes(int[] cityCodes)
{
  var tagNamesThatMatchedCityCodes = new List<string>();
  foreach (var tag in locationTags)
  {
    if (tag.CityCodes.Intersect(cityCodes).Any())
    {
      tagNamesThatMatchedCityCodes.Add(tag.TagName);
     }
   }

    return tagNamesThatMatchedCityCodes;
 }

Wenn wir die Leistung insbesondere bei großen Datensätzen optimieren möchten, können wir auch die Verwendung von „Yield Return“ bevorzugen, allerdings kann dies die Lesbarkeit des Codes beeinträchtigen. In solchen Schwierigkeiten müssen wir möglicherweise entscheiden, ob uns die Lesbarkeit oder die Leistung des Programms wichtig ist. Wenn ich beispielsweise einen Komprimierungsalgorithmus entwickle, möchte ich, dass er effizient funktioniert. Aber wenn ich ein Programm für Unternehmen entwickle und es nicht zu viel Systemlast verursacht, kann ich einen Leistungsverlust in Kauf nehmen, um einen lesbaren und wartbaren Code zu haben.

public IEnumerable<string> GetTagNamesThatMatchedCityCodes(int[] cityCodes)
{
  foreach (var tag in tags)
  {
    if (tag.CityCodes.Intersect(cityCodes).Any())
    {
      yield return tag.TagName;
     }
   }
}

Entwickler, Business-Analyst, Product Owner usw. Namen sollten für jedes Teammitglied klar und verständlich sein. Eric Evans definiert das Konzept der „ allgegenwärtigen Sprache “ in seinem Buch „Domain-Driven Design: Tackling Complexity in the Heart of Software“, einem weiteren Buch, das ich bei Gelegenheit zur Lektüre empfehlen würde.

Die allgegenwärtige Sprache ist eines der Schlüsselelemente im Umgang mit Komplexität. Dieses Bewusstsein verhindert auch Arbeitsunfälle.

Kurze und fokussierte Funktionen

Wir sollten die Funktionen so kurz und fokussiert wie möglich entwickeln. Sie sollten nur eine Mission (einzige Verantwortung) haben und diese Mission nach besten Kräften erfüllen. Dieses Bewusstsein verhindert auch Codeduplizierung.

Methoden mit vielen Codezeilen erhöhen die Komplexität. Insbesondere wenn wir eine if-Anweisung oder einen Codeblock mit Schleifen haben, können wir den Codeblock durch den Einsatz neuer Methoden verkürzen, um den Code verständlicher zu halten. Dies ist ein wichtiges Thema in Codeüberprüfungssitzungen, um eine erhöhte Komplexität zu vermeiden.

private void CreatePluralDependentMessageParts(int orderCount) 
{
  if (orderCount == 0) {
    FormatMessageForCustomerWithNoOrder();
   } else if (orderCount == 1) {
     FormatMessageForCustomerWithSingleOrder();
   } else {
     FormatMessageForCustomerWithManyOrders(orderCount);
   }
 }

Datenübertragungsobjekte sind eine saubere Möglichkeit, Daten zwischen Anwendungsschichten oder -funktionen zu übertragen.

Ich kann über ein Szenario sprechen, das Ihnen wahrscheinlich passieren wird, wenn Sie keine Datenübertragungsobjekte verwenden. Da im folgenden Beispiel dieselbe Art von Methodenparametern hintereinander auftritt, kann der Entwickler, der versucht, die Frist einzuhalten, die Parameter string email und appKey verwechseln. Es wird nicht lange dauern, bis Sie feststellen, dass Ihr E-Mail-Benachrichtigungsdienst ausgefallen ist.

public Customer(string name, string surname, string email, 
string appKey, int age, bool isPremium)
{
      Name = name;
      Surname = surname;
      Email = email;
      AppKey = appKey;
      Age = age;
      IsPremium = isPremium;
}

public Customer(CustomerDto customerDto)
 {
      Name = customerDto.Name;
      Surname = customerDto.Surname;
      Email = customerDto.Email;
      AppKey = customerDto.AppKey;
      Age = customerDto.Age;
      IsPremium = customerDto.IsPremium;
 }

Wir sollten es vermeiden, Kommentare zu schreiben. Auf den ersten Blick sollten wir erkennen können, welchen Zweck der Codeblock erfüllt. Für die Klarheit sind die richtige Benennung und Fokussierung sehr wichtig.

Wenn der Code nicht klar ist, sollten wir die Umgestaltung des Codes dem Kommentieren vorziehen. Es können jedoch Kommentare zu Situationen abgegeben werden, die einer Erklärung bedürfen.

// Check to see if the order is eligible for shipping
if (order.Payment.IsCompleted && order.Delivery.Slot.IsAvailable)

if (order.IsEligibleForShipping())

Vermeiden Sie die Verwendung magischer Zahlen in Ihrem Code. Durch die Verwendung durchsuchbarer Konstanten können Sie saubereren Code erstellen. Wenn Sie außerdem Änderungen an Ihrer Geschäftslogik vornehmen möchten, können Sie diese mühelos bearbeiten, ohne den gesamten Code scannen zu müssen.

if (password.Length > 10)
{
   throw new ValidationException($"Must be at least 10 characters");
}
if (password.Length > MAX_PASSWORD_LENGTH)
{
    throw new ValidationException($"Must be at least {MAX_PASSWORD_LENGTH} characters");
}

Manchmal stellen wir fest, dass die Codeblöcke, die zur Verarbeitung von Validierungsergebnissen oder zur Fehlerbehandlung geschrieben werden, zu stark zunehmen und den Code schwer lesbar machen. In der gesamten Anwendung sollte es einen Standardansatz für die Fehler- und Validierungsbehandlung geben. Und wir müssen sicherstellen, dass wir die Codebasis nicht verunreinigen. Um dies zu erreichen, ziehen wir es möglicherweise vor, eine Ausnahme auszulösen, anstatt Fehlercodes oder Flags zu übertragen. Wir können Middleware zur Fehlerbehandlung entwickeln, um die Ausnahmen zu protokollieren und unsere Antwort zu formatieren.

public bool IsValidPassword(string password)
 {
   if (string.IsNullOrEmpty(password))
     throw new ValidationException("Cannot be null or empty");
   if (password.Any(char.IsLetterOrDigit))
     throw new ValidationException("Must contain at least one special character");
   if (password.Length > MAX_PASSWORD_LENGTH)
     throw new ValidationException($"Must be at least {MAX_PASSWORD_LENGTH} characters");

    return true;
  }

Für die psychische Gesundheit von uns selbst und unserem Team sollten wir versuchen, unseren Code zu verbessern, indem wir unregelmäßige Entwicklungen vermeiden. Schmutziger Code führt in Zukunft zu mehr Zeitverschwendung und, schlimmer noch, zu sehr schwierig zu lösenden Problemen. Wenn Sie sich an die Prinzipien des sauberen Codes halten, werden Sie feststellen, dass Sie Code von besserer Qualität entwickeln und die Ergebnisse Ihrer Entwicklungen Sie zufriedener machen.