Sauberer Code: Kluger Entwickler vs. Professioneller Entwickler

Clean Code: Smart Developer vs. Professional Developer anhand von Scala-Codebeispielen

Heutzutage gibt es viele Arten von Entwicklern, mit oder ohne Ingenieurdiplom. Viele Leute schreiben Code, um ihren Lebensunterhalt zu verdienen und / oder Spaß zu haben.

Das Schreiben von Produktionscode ist jedoch immer komplexer und anspruchsvoller als andere. Wir unterscheiden zwei Arten von Entwicklern: Der eine ist äußerst intelligent, legt jedoch weniger Aufwand auf wartbaren Code, während der andere professionell ist und fest an wartbaren, lesbaren und sauberen Code glaubt.

Der professionelle Entwickler wird weniger Entwickler haben, die auf Erklärungen zur Verwendung seines Codes warten, während der smarte Entwickler eine endlose Reihe von Leuten hat, die Fragen zu seinen Bibliotheken stellen.

Kluge Entwickler

Wir haben alle den "intelligenten" Entwickler getroffen, der komplexe mathematische Gleichungen, endlose Lambda-Ausdrücke und extrem generischen Code mit wenig bis gar keiner Dokumentation schreibt. Derjenige, der andere Bibliotheken nicht nutzt und alles von Grund auf neu entwickelt, nur weil er es besser weiß.

Obwohl dies in Ordnung ist, scheitern einige clevere Entwickler schlecht, wenn es um sauberen Code geht. Sie schreiben Code, der zu allgemein ist. Das Hinzufügen von Abhängigkeiten und der Browder-API schadet der einfachen Wiederverwendung des Codes.

Professionelle Entwickler

Professionelle Entwickler sind selten anzutreffen, normalerweise erfahren und haben eine große Leidenschaft für die Programmierung. Professionelle Entwickler wissen, dass die Art, wie sie Code schreiben, die Art ist, wie sie von ihren Kollegen wahrgenommen werden. Sie unterstützen sauberen Code und hohe Testabdeckung, Mocks, ITs und im Grunde alles, was ihre Signatur (Code) sicherstellt, wird für immer leben. Sie glauben an wartbaren Code und ihr Motto lautet:

Klarheit ist KÖNIG!

Beispiele für saubere Scala-Codes

Schauen wir uns einige Beispiele für Scala-Codes an, die professionelle Entwickler von intelligenten unterscheiden:

Schlauer Entwickler:

Merkmal SocketFactory erweitert (SocketAddress => Socket)

Professioneller Entwickler:

Typ SocketFactory = SocketAddress => Socket

Eine SocketFactory ist eine Funktion, die einen Socket erzeugt. Die Verwendung eines Typ-Alias ​​ist in diesem Fall besser, wiederverwendbar und besser lesbar.

Kollektionen in scala erstellen:

Schlauer Entwickler:

scala.collection.mutable._
val set = Set ()

Professioneller Entwickler:

Importieren Sie scala.collection.mutable
val set = mutable.Set ()

Im zweiten Beispiel ist leicht zu verstehen, welcher Auflistungstyp verwendet wird. Dies ist normalerweise wichtig, wenn APIs in Scala erstellt werden.

Wenn Sie neue Parameter deklarieren, ist es besser, auch den Typ hinzuzufügen. Auf diese Weise ist es viel klarer:

var set: mutable.Set [String] = mutable.Set ()

Lust auf Lambda-Ausdruck:

Schlauer Entwickler:

val votes = Seq (("scala", 1), ("java", 4), ("scala", 10), ("scala", 1), ("python", 10))
val orderedVotes = votes
  .groupBy (_._ 1)
  .map {case (was zählt) =>
  (was zählt.foldLeft (0) (_ + _._ 2))
  } .toSeq
  .sortBy (_._ 2)
  .umkehren

Professioneller Entwickler:

val votes = Seq (("scala", 1), ("java", 4), ("scala", 10), ("scala", 1), ("python", 10))
val votesByLang = votes.groupBy ({case (lang, _) => lang})
val sumByLang = votesByLang.map (
{case (lang, counts) =>
       val countsOnly = counts.map ({case (_, count) => count})
       (lang, countsOnly.sum)
})
val orderedVotes = sumByLang.toSeq
.sortBy ({case (_, count) => count})
.umkehren

Das Beispiel des smarten Entwicklers ist prägnant und korrekt, aber fast jeder Leser wird Schwierigkeiten haben, die ursprüngliche Absicht des Autors wiederherzustellen. Eine Strategie, die häufig zur Verdeutlichung dient, besteht darin, die im zweiten Beispiel angegebenen Zwischenergebnisse und Parameter zu benennen. Das professionelle Beispiel ist für eine Person mit Grundkenntnissen in Scala selbsterklärend.

Wissen, wann man einen Typalias verwendet:

Schlauer Entwickler:

Typ IntMaker = () => Int
IntMaker

Professioneller Entwickler:

Klasse ConcurrentPool [K, V] {
Typ Warteschlange = ConcurrentLinkedQueue [V]
type Map = ConcurrentHashMap [K, Queue]
...
}

IntMaker ist kurz und verwendet einen gebräuchlichen Typ. Warteschlange und Karte sind jedoch hilfreich, da sie den Zweck kommunizieren und die Kürze verbessern.

Hier einige Beispiele für das Schreiben eines lesbaren, professionellen Codes im Vergleich zu einem intelligenten Code. Denken Sie daran, dass Code wartbar und ansonsten verwendbar sein muss, es wird stinken!

Einige Informationen zum Schlüsselwort scala type:

Scala-Schlüsselwort

  • Das Schlüsselwort type in Scala kann viel mehr als nur einen komplizierten Typ in einen kürzeren Namen umwandeln. Es führt Typmitglieder ein. In Scala können Klassen auch Typmitglieder haben. Das Typsystem ersetzt lediglich den Alias ​​durch den tatsächlichen Typ, wenn die Typprüfung durchgeführt wird.
  • Typmember können auch als zwei Generika betrachtet werden, da viele der Dinge, die Sie mit Generika implementieren können, in abstrakte Typmember übersetzt werden können.

Beispiel

Merkmalsbasis {
  Typ T

  Def-Methode: T
}

Klasse Implementierung erweitert Basis {
  Typ T = Int

  Def-Methode: T = 42
}

Typ ist ein starkes Merkmal, für weitere Details klicken Sie hier.

Ich hoffe, diese Beispiele werden Sie auf dem Weg leiten. Denken Sie daran, dass bei Produktionscode alles um Lesbarkeit und Wartbarkeit geht.

Imbissbuden

  • Deklarieren Sie Ihre Parametertypen
  • Lass dich nicht von Lambda-Funktionen verrückt machen
  • Verwenden Sie bei Bedarf das Schlüsselwort type
  • Klarheit ist KÖNIG!

Folgen Sie mir auf Medium, um weitere Beiträge über Scala, sauberen Code und Unsinn von Software-Ingenieuren zu erhalten. Prost !