Wie die Codequalität gemessen wird: Code-Review bei Yalantis

Programmierer sind die Autoren großartiger Programme, ebenso wie Autoren der meistverkauften Romane. Aber hinter den Kulissen gibt es immer viele Menschen, die an dem Prozess beteiligt sind. 

Der beste Code – wie die besten Produkte jeglicher Art – ist das Ergebnis einer Zusammenarbeit. Alle Programmierer, sowohl erfahrene Softwareingenieure als auch Neulinge, brauchen gelegentlich jemanden, der einen neuen Blick auf ihren Code wirft und dort Probleme entdeckt. So gewährleisten wir in Yalantis die Codequalität.

Wir führen regelmäßig Code-Reviews unserer Projekte durch, da dies die Code-Effizienz erheblich erhöht und die native App-Entwicklung optimiert.

In diesem Artikel zeigen wir Ihnen, warum und wie wir Code-Reviews durchführen und geben einige nützliche Tipps zur Durchführung eines Code-Reviews.

Code-Reviews verfolgen vier Hauptziele

Wir haben Richtlinien und Tutorials zur Code-Überprüfung für unser Android-Team geschrieben, um den Code-Überprüfungsprozess reibungslos und transparent zu gestalten. Unsere Richtlinien basieren auf bewährten Praktiken und Techniken zur Code-Überprüfung in Android, um die Codequalität zu verbessern. 

Im Jahr 2019 führte Google seine eigenen Leitlinien für Code-Reviews sowohl für Entwickler als auch für Manager ein. Entwickler und Code-Reviewer. Diese Anleitungen beeinflussten unseren Code-Review-Prozess, und wir empfehlen Ihnen dringend, sie sich anzusehen. 

Der Code-Review-Prozess bei Yalantis umfasst eine linienweise Codeanalyse, eine Checkliste für die Code-Review-Überprüfung und Dokumentation zur Vorschlagung von Verbesserungen. Sehen wir uns an, wie man einen Android-Code-Review durchführt.

Im Folgenden haben wir die wichtigsten Aspekte aufgeführt, auf die ein Code-Reviewer achten sollte. 

1. Dokumentenklarheit

Manchmal muss man sich entscheiden, ob man eine bestehende Anwendung weiterbetreiben oder einen anderen Entwickler einsetzen soll. Entwickler, die ursprünglich an einem Projekt nicht beteiligt waren, müssen jede einzelne Zeile Code genau verstehen. Je klarer die Dokumentation ist, desto schneller kann die App entwickelt werden und desto weniger Ressourcen wird Ihre Organisation aufwenden müssen.

Wenn sich der Code geändert hat, ist es wichtig zu prüfen, ob auch die dazugehörigen Dokumentation (README, g3doc-Seiten usw.) aktualisiert wurde. Wenn Sie Code löschen oder verfallen lassen, sollten Sie prüfen, ob die entsprechende Dokumentation ebenfalls gelöscht werden sollte. Außerdem sollten Sie die Dokumentation auf logische Fehler überprüfen.

2. Code-Stil

Der Code-Stil umfasst mehrere wichtige Aspekte: 

• Kommentare

Einige Codekommentare können keinen Sinn ergeben. Oder sie sind in einer Fremdsprache verfasst. Kommentare sollten klar und nützlich sein und vor allem erklären, was geändert werden sollte. Unser Unternehmensstandard ist, alle Kommentare auf Englisch zu verwenden, auch wenn Englisch nicht unsere Muttersprache ist.

Wir verwenden Englisch aus zwei Gründen:

Entwickler für die Android-Plattform aus anderen Ländern könnten künftig unsere Quellcode verwenden.

Wir sind ein aktiver Mitwirkender an Open-Source-Software, die von anderen Unternehmen weltweit weit verbreitet eingesetzt wird. Schauen Sie sich uCrop an, unsere Open-Source-Bibliothek für das Bildbearbeiten für Android, die von TripAdvisor und Pinterest verwendet wird, und sehen Sie sich unsere anderen iOS- und Android-Open-Source-Projekte an.

• Benennen

Benennungskonventionen machen Android-Code verständlicher. Alle Benennungskonventionen sind in unseren internen Android-Code-Richtlinien von Yalantis festgelegt.

Wenn in Ihrem Team keine Konventionen gelten, können Sie diese verwenden. Namenskonventionen von dem Android Open Source Project, das eine strukturierte Liste nützlicher Namensbeispiele enthält. 

Es gibt auch einige Details, die Sie beachten sollten, wie z. B. die Dateistruktur, Syntaxfehler, die Verwendung von Klammern und weißen Leerzeichen usw. Erstellen Sie Ihre eigene Style-Richtlinie anhand von Code-Standards oder verwenden Sie eine bekannte Richtlinie wie die Kotlin-Stil-Richtlinien von Android-Entwicklern oder Java-Stil-Handbuch von Google. Und natürlich enthält “Clean Code: A Handbook of Agile Software Craftsmanship” eine umfangreiche Liste von Empfehlungen bezüglich sauberer Code-Ausführung und Code-Design. 

Hier ist ein Ausschnitt aus unserem uCrop-Projekt, der zeigt, wie wir Felder und Methoden benennen und wie wir Kommentare schreiben:

    öffentlich statisch Finale float DEFAULT_MAX_SCALE_MULTIPLIER = 10,0f;
    privat Finale RectF mCropRect = Neu RectF();
    privat Finale Matrix mTempMatrix = Neu Matrix();
    privat float mTargetAspectRatio;
    /**
     * Diese Methode ändert die Bildskalierung für einen bestimmten Wert, der mit den Punkten (px, py) verbunden ist, aber nur dann, wenn
     * Die resultierende Skala liegt in den Min-/Max-Grenzen.
     *
     * @param deltaScale - Skalierungswert
     * @param px - Skalierungszentrum X
     * @param py - Skalenzentrum Y
     */
    öffentlich void postScale(float deltaScale, float px, float py) {
        wenn (deltaScale > 1 && getCurrentScale() * deltaScale <= getMaxScale()) {
            super.postScale(deltaScale, px, py);
        } else wenn (deltaScale < 1 && getCurrentScale() * deltaScale >= getMinScale()) {
            super.postScale(deltaScale, px, py);
        }
    }

3. Architekturformen

Eine App-Architektur ist ein Plan für das Projekt. Sie definiert die Aufgabenbereiche, die von den Design- und Implementierungsteams erledigt werden müssen. Eine Softwarearchitektur legt technische Standards fest und regelt, wie die App-Architektur aufgebaut werden soll.   

Bei der Code-Überprüfung von Android-Projekten überprüfen wir, ob das Architekturmuster korrekt implementiert ist (d. h., ob die Geschäftslogik von der View-Layer getrennt ist). Außerdem prüfen wir die Reinheit und Korrektheit der Verbindungen zwischen den Komponenten.

Beispielsweise verwenden wir das Modell-Ansicht-ViewModel-Architekturmuster (MVVM) und den Clean Architecture-Ansatz bei der Entwicklung von Android-Apps. Bei einer Code-Überprüfung überprüfen wir, ob ein Entwickler die Prinzipien dieser Architekturmuster befolgt hat. 

4. Einfachheit

Bei Yalantis folgen wir dem KISS-Prinzip (Keep It Short and Simple), wonach Einfachheit ein zentrales Ziel in der Gestaltung sein sollte und unnötige Komplexität vermieden werden sollte. 

Bei der Codeanalyse ist es entscheidend, sicherzustellen, dass Code von anderen Entwicklern leicht verstanden werden kann und dass Änderungen keine neuen Fehler verursachen. Prüfen Sie, dass Klassen und Funktionen nicht zu komplex sind und dass keine überflüssige Funktionalität vorhanden ist.

5. Fehlerbehandlung

Fehlermanagement ist für jedes Softwareprojekt entscheidend. Bei Yalantis prüfen wir, ob der von uns überprüfte Code alle möglichen Fehler berücksichtigt, die aus Eingaben des Benutzers, Serverantworten und Datenbanktransaktionen resultieren.

Die Fehlerbehandlung geht nicht nur darum, erkannte Fehler zu protokollieren. Häufig beinhaltet die Fehlerbehandlung auch die Information des Benutzers darüber, was genau in der Anwendung schiefgelaufen ist und wie das Problem behoben werden kann.

Hier ist ein Codeabschnitt aus einem ViewModel, der eine API-Anforderung veranschaulicht, die sowohl das Ergebnis als auch mögliche Fehler behandelt, indem in der entsprechenden View-Klasse entsprechende Methoden aufgerufen werden:

getUserUseCase
.observeUserById(userId)
.doOnSubscribe{ progress.value = wahr }
.doOnTerminate{ progress.value = Falsch }
.subscribeBy(
onNext = { userLiveData.value = it }, 
onError = {handleError(it)}
)
.addTo(compositeDisposable)

6. Testabdeckung

Obwohl wir uns stark auf unser QA-Team für erfolgreiche Releases verlassen, geben wir Code erst in die Produktion, nachdem wir Tests für die spezifische Funktionalität erstellt haben, die wir implementieren. Das Test-Early-Prinzip hilft uns, Fehler bereits in der Anfangsphase des Projektlebenszyklus zu erkennen und zu beheben.

Bei der Codeinspektion von Android sehen wir, welcher Prozentsatz des Codes tatsächlich von unseren Einheitstests abgedeckt wird. Wir legen größten Wert auf die Einheitstests der Geschäftslogik, führen aber auch UI-Tests durch. Nach den Regeln in Von Lars Vogel Tutorial zum Entwickeln von Android-Unit- und Instrumentierungstests:

• 70–80% der Tests sollten Einheitstests sein, um die Stabilität Ihrer Codebasis zu gewährleisten.

• 20–30% Tests sollten funktionale Tests sein, um sicherzustellen, dass die Anwendung tatsächlich funktioniert.

7. Leistungsüberwachung

Obwohl die mobile Technologie rasant weiterentwickelt wird, ist die Rechenleistung der durchschnittlichen Android-Geräte immer noch begrenzt, die Speicherkapazität ist begrenzt und die Akkukapazität bleibt eine der wertvollsten Ressourcen. Wenn wir die Codeleistung nicht überwachen, kann das Produkt, das wir entwickeln, beim Markteintritt nicht überzeugen.

Die Performance einer App hängt nicht nur von der Zuverlässigkeit des Android-Quellcodes ab, sondern auch von Drittanbieter-SDKs, Betriebssystemen, Geräten, Netzwerkbegrenzungen, Datendiensten und APIs, die die mobile Anwendung unterstützen.

Um herauszufinden, was die Ursache für bestimmte Leistungsprobleme ist, müssen wir uns die Technik hinter den Kulissen ansehen. Wir verwenden Android Profiler Um Daten über die Ausführung einer App zu sammeln. Außerdem verwenden wir Simulatoren mit Diagnosefunktionen, um schnell die Ursachen von Fehlern zu identifizieren, wenn etwas schief geht.

Wenn wir beispielsweise während der Überprüfung des Android-Quellcodes feststellen, dass eine App häufig Anfragen an den Server sendet, implementieren wir eine intelligente HTTP-Caching-Technik. Wenn eine App eine erhebliche Akkulaufzeit verringert, stellen wir sicher, dass sie keine unnötigen Standortinformationen anfordert.

8. Sicherheit

Ziel der Überprüfung von Sicherheitscodes in Android-Projekten ist es, Sicherheitslücken zu erkennen und Schwachstellen zu identifizieren. Ursachen für diese Schwachstellen können unzureichend sichere Code-Richtlinien, Mängel in der Geschäftslogik, internen Strukturen oder im Systemdesign sein.

Beispielsweise prüfen wir bei unseren Sicherheitsüberprüfungen, ob ein Programm die Übertragung von Daten zwischen Server und Client über HTTPS/SSL nutzt, dass die Daten verschlüsselt übertragen werden und ob der Code selbst nicht offensichtlich ist.

Unsere Sicherheitscode-Überprüfung entdeckt Sicherheitslücken und versteckte Hintertüren.

Android-Code-Review-Tools

Code-Review ist eine gute Entwicklungspraxis, erfordert jedoch Zeit und Mühe von Seiten des Reviewers. Außerdem werden bei komplexeren Apps und mit zunehmender Anzahl von Entwicklern, die an dem Projekt arbeiten, mehr Ressourcen für Code-Review benötigt.

Automatisierte Code-Review-Tools erleichtern die Entwicklung, indem sie den Code regelmäßig gegen die Anforderungen überprüft. Hier ist eine Liste der beliebtesten Code-Review-Software:

• Checkstyle ist ein Open-Source-Tool, das Entwicklern hilft, zu prüfen, ob ihre Codebasis den relevanten Styleguides entspricht. Es wurde für die Styleguides von Google und Sun optimiert. Es überprüft jedoch nur Java-Code.

• SonarQube SonarQube ist ein leistungsstarker Codeanalysator, der mit 27 Programmiersprachen funktioniert, nahtlos mit Build-Frameworks zusammenarbeitet und mit beliebten CI-Engines wie Jenkins TeamCity integriert werden kann. Wir verwenden SonarQube für regelmäßige Codeprüfungen in den meisten unserer Projekte. 

Codacy ist ein Defekt-Tracking-System, das automatisierte Code-Tests und -Überprüfungen ermöglicht. Mit seinem statischen Code-Analysetool können Entwickler Sicherheitsbedenken, Duplikate, Komplexität, Stilverletzungen und Abnahme der Abdeckung in jeder Commit- und Pull-Request-Anforderung automatisch identifizieren und beheben – direkt aus ihrem Git-Workflow. Codacy lässt sich problemlos mit GitHub, Bitbucket und Gitlab integrieren und analysiert 28 verschiedene Programmiersprachen.

Für jede Code-Überprüfung erstellen wir eine Checkliste für Android-Code-Überprüfungen und schlagen Code-Verbesserungen vor, die in fünf Kategorien unterteilt werden können:

1. Refactoring, um den Code sauberer, zuverlässiger und wartbarer zu machen
2. Die Wurzeln der Probleme beheben, die wir festgestellt haben
3. Neuer Schreiben einiger Teile des Codes  
4. Optimierung der Prozesse mithilfe einer Datenbank oder einer API oder Änderung einer Bibliothek
5. Das Projekt neu von Grund auf schreiben

Bitte teilen Sie uns Bescheid Wenn Sie Fragen zu Android-Code-Review haben, helfen wir Ihnen gerne weiter und hören Ihre Anregungen gerne zu.