Kategorie: Theorie

Einleitung

Die „Boy Scout Rule“ (BSR) ist ein ethisches Prinzip, das besagt: „Hinterlasse den Campingplatz sauberer, als du ihn vorgefunden hast.“ In der Softwareentwicklung bedeutet dies, den Code immer ein wenig besser zu hinterlassen, als man ihn vorgefunden hat. Dieser Artikel richtet sich an Intermediate Developer, die sich zu Senior Developer weiterentwickeln und ihre Fähigkeiten verbessern möchten.

Was ist die Boy Scout Rule?

Die Boy Scout Rule ist ein ethisches Prinzip, das besagt, dass man immer einen kleinen Beitrag zur Verbesserung des Codes leisten sollte, den man bearbeitet. Die Idee ist, dass viele kleine Verbesserungen im Laufe der Zeit zu einem deutlich besseren Codebase führen können.

Warum ist die Boy Scout Rule wichtig?

Code-Qualität

Die Anwendung der Boy Scout Rule führt zu einer kontinuierlichen Verbesserung der Code-Qualität. Dies ist besonders wichtig in agilen Entwicklungsumgebungen, wo der Code ständig geändert wird.

Teamdynamik

Die Boy Scout Rule fördert eine Kultur der Verantwortung und des Respekts innerhalb des Entwicklungsteams. Wenn jeder Entwickler sich bemüht, den Code zu verbessern, wird die Teamdynamik positiv beeinflusst.

Wie implementiert man die Boy Scout Rule?

Code Reviews

Nutzen Sie Code Reviews als Gelegenheit, um die Boy Scout Rule anzuwenden. Wenn Sie auf einen Abschnitt mit schlecht geschriebenem Code stoßen, verbessern Sie ihn.

Refactoring

Refactoring ist der Prozess der Änderung eines Software-Systems, ohne sein Verhalten zu ändern. Es ist eine hervorragende Gelegenheit, die Boy Scout Rule anzuwenden und den Code sauberer und effizienter zu gestalten.

Herausforderungen und Lösungen

Definition von „Sauber“

Ein häufiges Problem bei der Anwendung der Boy Scout Rule ist die fehlende Klarheit darüber, was „sauberer“ oder „besser“ bedeutet. Hier ist es wichtig, dass das Team gemeinsame Standards und Best Practices festlegt.

Zeitmanagement

Es kann schwierig sein, die Zeit für die Anwendung der Boy Scout Rule zu finden, insbesondere in einem hektischen Entwicklungszyklus. Die Lösung besteht darin, kleine, inkrementelle Verbesserungen vorzunehmen, die im Laufe der Zeit addiert werden.

FAQ

Was ist die Boy Scout Rule?

Die Boy Scout Rule besagt, dass man den Code immer ein wenig besser hinterlassen sollte, als man ihn vorgefunden hat.

Wie kann ich die Boy Scout Rule in meinem Team implementieren?

Beginnen Sie mit Code Reviews und Refactoring als Möglichkeiten, die Boy Scout Rule anzuwenden. Stellen Sie sicher, dass das Team gemeinsame Standards für „sauberen Code“ hat.

Ist die Boy Scout Rule immer anwendbar?

Es gibt Situationen, in denen die Anwendung der Boy Scout Rule nicht praktikabel ist. In solchen Fällen ist es wichtig, das Risiko gegen den Nutzen abzuwägen.

Schlussfolgerung

Die Boy Scout Rule ist ein mächtiges Prinzip, das zur Verbesserung der Code-Qualität und der Teamdynamik beitragen kann. Für Intermediate Developer, die sich zu Senior Developer weiterentwickeln möchten, bietet die Anwendung dieser Regel eine hervorragende Gelegenheit, Führungsqualitäten zu demonstrieren und einen positiven Einfluss auf das Projekt zu haben.

Du willst ein besserer Softwareentwickler werden? Es gibt 3 Methoden mit denen du ein besserer Entwickler wirst. Ganz oben steht natürlich die Übung bzw. Erfahrung, umso mehr du programmierst umso besser wirst du. Der zweite Punkt ist zu lernen wie andere Entwickler arbeiten, kleine Kinder lernen schon mit dieser Methode, abschauen und nachahmen. Der letzte Punkt ist Kommunikation, bleibe immer auf dem aktuellen Stand der Technologien, da in wenigen Jahren riesige Änderungen im Bereich Softwareentwicklung passieren.

Übung

Was bedeutet Übung? Einfach ausgedrückt, baue Dummy Projekte. Erstelle einen Klon von großen Projekten die du gut findest oder die du als schwer umsetzbar empfindest. Du lernst am meisten wenn du dir schwere Projekte vornimmst. Falls du noch nicht so erfahren bist und mit einem einfachen Projekt starten willst, nimm die ein evergreen Projekt. Das bedeutet baue eine Todo App oder eine Blogsoftware. Halte die App simpel und einfach, gehe nicht zu tief ins Detail, es soll kein Projekt für die Ewigkeit enstehen, baue lieber die Kernkomponenten und sammle dadurch Erfahrungen.

Es wird hoffentlich der Punkt kommen an dem du dich überfordert fühlst, an der Stelle weißt du jetzt kommt die Lernkurve. Erst an diesem Punkt fängst du an besser zu werden, wenn du recherchieren musst und neue Dinge durch ausprobieren lernst.

Dies ist ein Endloser Prozess, du kannst mit dieser Strategie immer was neues lernen. Ich als erfahrener Entwickler tue dies ständig, ich suche mir ein Problem, z.B. wollte ich meine Apache Log Files mit Node analysieren, aber zu diesem Thema findet man keine Tutorials im Netz. Deswegen musste ich mich mit Dokumentationen auseinander setzen und mich tiefer mit Regex beschäftigen.

Nachahmen

Die einfachste Version ist das nachprogrammieren von Tutorials. Dabei lernst du vom Autor wie er seine Probleme angegangen ist und diese dann gelöst hat. Eine alternative ist, sich Software von anderen Programmierern anzuschauen und versuchen diese zu verstehen. Gehe auf Github und suche dir ein spannendes Projekt raus. Klone das Projekt und lese dir den Quelltext durch, das wird dir in einer Firma oft passieren, du sollst eine Software weiterentwickeln und musst aus dem Code lernen da der Kollege gerade im Urlaub ist. Wenn du dir jetzt ein Projekt auf Github ausgesucht hast, versuche dies zu erweitern. Als Beispiel kannst du dir mein Apache Logfile-Analyse Software anschauen. Die par Zeilen Code sind schnell überblickt, versuche meinen Code zu optimieren, vielleicht hast du eine Idee, wie eine Sache besser gemacht werden kann.

Kommunikation

Trends

Als Entwickler auf dem neusten Stand zu sein ist sehr wichtig, was in der Softwareentwicklung in einem oder zwei Jahren passiert ist gigantisch. Es gibt wahrscheinlich kein anderen Beruf auf dem du immer auf dem aktuellen Stand sein musst. Deswegen lese Nachrichtenseiten wie Golem, Heise oder T3N. Suche dir am besten noch Blogs von anderen Entwicklern.

Communitys

Du solltest auf Twitter aktiv werden, dort findest du eine riesige internationale Entwickler Community. Zum Beispiel habe ich auf Twitter das erste mal von yarn gehört, yarn ersetzt npm und ist performanter als npm. Seit dem benutze ich yarn und bin sehr zufrieden damit. Eine andere Plattform ist Stackoverflow, versuche doch mal ein par Fragen zu beantworten um anderen Entwicklern zu helfen, oder versuche Lösungsansätze zu finden und warte bis die Frage beantwortet ist, danach vergleiche deine Lösung mit der Antwort und wenn du deine Lösung als eleganter ansiehst poste diese.

Bonus

Des weiteren kannst du regelmäßig dein Arbeitgeber wechseln, dadurch wirst du immer wieder gefordert neue Arbeitsweisen zu lernen. Wechsel alle 4-5 Jahre dein Arbeitgeber, dadurch baust du dir auch eine gutes Portfolio auf und wirst besser bezahlst, weil du diese Erfahrungen aus anderen Firmen mitbringst.

Kurz gesagt rekursives Programmieren bedeutet, dass eine Funktion oder Methode sich selbst aufruft. Dies hat den Vorteil das der Code eleganter wirkt, sowie Wartbarer und effizienter ist. Ich werde anhand eines Beispiels erläutern, wie diese Programmierart eingesetzt werden kann.

Wikipedia definiert rekursive wie folgt:

Als Rekursion (lateinisch recurrere ‚zurücklaufen‘) bezeichnet man den abstrakten Vorgang, dass Regeln auf ein Produkt, das sie hervorgebracht haben, von neuem angewandt werden. Hierdurch entstehen potenziell unendliche Schleifen. Regeln bzw. Regelsysteme heißen rekursiv, wenn sie die Eigenschaft haben, Rekursion im Prinzip zuzulassen.

Palindrom Beispiel

Das Beispiel wird ein Palindrom-Tester sein, ein Palindrom ist ein Wort das Vorwärts sowie Rückwärts gleich geschrieben wird z.B. Regallager oder Rentner. Um dies zu prüfen habe ich folgende Funktion entworfen:

function isPalindrome(myString) {
    if (myString.length <= 1) return true;
    if (myString.charAt(0) != myString.charAt(myString.length - 1)) return false;
    return isPalindrome(myString.substr(1, myString.length - 2)); 
}

Wie man sehen kann wird in Zeile 3 die Funktion selbst aufgerufen, daran erkennt man das es sich um eine rekursive Funktion handelt.

Jetzt aber von Anfang an, Zeile 1:

if (myString.length <= 1) return true;

Hier wird geprüft ob der String 1 Zeichen lang ist, da ein Zeichen Vorwärts und Rückwärts gleich ist muss es ein Palindrom sein.

Zeile 2:

if (myString.charAt(0) != myString.charAt(myString.length - 1)) return false;

Jetzt prüft die Funktion ob das erste Zeichen und das letzte Zeichen identisch ist, wenn nein soll die Funktion false zurückgeben.

Zeile 3:

return isPalindrome(myString.substr(1, myString.length -2));

Jetzt geht es los, hier wird die Funktion zu einer rekursiven Funktion, da die Funktion sich selbst aufrufen tut. Als Parameter wird der String übergeben, aber vorher wird der String noch beschnitten. Es wird das erste und das letzte Zeichen entfernt. So wird der String von außen nach innen durchgearbeitet.

Debug Beispiel

function isPalindrome(myString) {
    if (myString.length <= 1) return true;
    console.log("(length > 1) = false");
    if (myString.charAt(0) != myString.charAt(myString.length - 1)) return false;
    console.log("(char 1 == char last) = true");
    return isPalindrome(myString.substr(1, myString.length - 2)); 
}

console.log(isPalindrome("Rentner".toUpperCase()));

Gibt folgendes Aus:

(length > 1) = false
(char 1 == char last) = true
(length > 1) = false
(char 1 == char last) = true
(length > 1) = false
(char 1 == char last) = true
-> true

Es muss vorher toUpperCase angewandt werden, da sonst false ausgegebn wird, da R != r.

console.log(isPalindrome("Palindrome".toUpperCase()));

(length > 1) = false
-> false

verschachteltes Objekt analysieren

In diesem Beispiel erläutere ich, wie man ein Objekt, mit einer Baumstruktur, mit einer rekursiven Funktion analysiert. Zum Beispiel, du hast ein Object in dem ein Array ist, in diesem wiederum mehrere Objekte mit jeweils einem Array ist und diesen Array ist wieder ein Objekt mit einem Array usw.. Praktisches Beispiel: ein Umfragetool mit N Unterkategorien hat Fragen die Pflichtfelder sind und neben diesen Fragen kann es wieder eine Unterkategorie geben mit nicht Pflichtfeldern geben. Jetzt ist die Aufgabe, eine Anzeige zu entwickeln die anzeigt wie viele Pflichtfelder es gibt.

Beispielobjekt

In diesem Beispiel gibt „state“ an, ob es sich um Pflichtfelder handelt.

let myObj = {
  nestedObj: [
    {
      questions: [{},{}],
      state: true,
      nestedObj: [
       {
        questions: [{},{}],
        state: false
       },
       {
        questions: [{}],
        state: true,
        nestedObj: [
         {
           questions: [{},{}],
           state: true
         },
         {
           questions: [{}],
           state: false
         }
        ]
       }
     ]
    }
  ],
  questions: [{},{},{}],
  state: true
}

Jetzt willst du herausfinden, wie viele „questions“, mit dem „state“ true, existieren. Das Problem ist dabei, das es sich um eine Baumstruktur handelt. Deswegen kann es passieren, dass die rekursive Funktion sich mehrfach selbst aufruft. Deswegen muss der Ausgangswert mal X Objekte im Array subtrahiert werden.

const reducer = (accumulator, currentValue) => accumulator + currentValue;
function countQuestions(obj, count = 0) {
  if(obj.state)
    count += obj.questions.length;
  
  if(typeof obj.nestedObj != 'undefined' && obj.nestedObj.length != 0){
    return obj.nestedObj.map(nestedObj => countQuestions(nestedObj, count)).reduce(reducer) - (count * (obj.nestedObj.length-1));   
  }
  else
    return count;
}

Code Analyse

const reducer = (accumulator, currentValue) => accumulator + currentValue;

Das ist eine Helferfunktion für reduce, hierdrauf werde ich nicht weiter eingehen, einfach auf MDN web docs nachlesen was da passiert. Hinsweis: es handelt sich um eine ES6 Arrow Funktion.

if(obj.state)
    count += obj.questions.length;

In dieser If Abfrage, wird geprüft ob „state“ true ist und somit als Pflichtfeld gilt. Falls die Bedinung true, also Wahr, ist, sollen die Artikelanzahl summiert werden.

if(typeof obj.nestedObj != 'undefined' && obj.nestedObj.length != 0){
    return obj.nestedObj.map(nestedObj => countQuestions(nestedObj, count)).reduce(reducer) - (count * (obj.nestedObj.length-1));   
}

Jetzt geht es ans eingemachte, zuerst wird geprüft ob das Objekt überhaupt ein Array hat und ob dieses auch Elemente beinhaltet.

obj.nestedObj.map(nestedObj => countQuestions(nestedObj, count))

Die Map Funktion in Kombination mit der Arrow Funktion, ruft die rekursive Funktion mehrfach auf. Sprich die Map Funktion würde ein Array mit der Anzahl der Pflichtfelder + der bisherigen gezählten Pflichtfelder zurückgeben. Beispiel: aktuell 3 Pflichtfelder und es gibt 2 Sub-Elemente mit jeweils 2 Pflichtfeldern, würde Map [5,5] zurückgeben.

.reduce(reducer)

Addiert alle Zahlenwerte im Array, bleiben wir bei dem Beispiel mit [5,5], würde reduce 10 zurückgeben.

- (count * (obj.nestedObj.length-1)

Da wir Ja nicht 10 Pflichtfelder haben, sondern 3 + 2 + 2 = 7, müssen wir den Basiswert (3) N-1 mal von dem Ergebnis abziehen, in diesem Fall: 2 Objekte – 1 = 1. Spricht unsere Rechnung: (3 + 2) + (3 + 2) – (3 * 1).

in JSBin öffnen