Okt 17 2011

Clean Code – Prinzipien zum sauberen Programmieren

Entwickler wissen wie es ist, wenn man sich durch unsauberen Code durcharbeiten muss. Der Code ist „schwer“ zu lesen und es macht auch recht wenig Spaß. Man wird dadurch gebremst und die Produktivität sinkt auch bis in den Keller. Nach und nach häufen sich Berge von diesen Codeschnipseln an und der Code wird dadurch nicht mehr wartbar.

Wie kann man denn nun gegen diese Unsauberkeit entgegenwirken? Es gibt sehr viele Prinzipen im „Clean Code“, die gegen die unsaubere Programmierung wirken sollen. Einige dieser Prinzipien werde ich meinen nächsten Artikeln erläutern. Es sind sehr viele, wobei auch einige umstritten, sehr schwer anzuwenden oder auch nicht eindeutig sind und somit wegfallen. Aber darüber hinaus gibt es noch genug Prinzipien, die man erklären kann, versprochen ;) .

Die Prinzipen des „Clean Code“ beschreiben Strukturen/Architekturen in der objektorientierten Softwareentwicklung auf Quellcodeebene. Das Ziel dieser Prinzipien ist es, für lose Kopplung und verständliche Strukturen zu sorgen bzw. diese Strukturen wieder herzustellen.

Nun möchte ich euch die grundlegenden Dinge erklären, die eingehalten werden müssen, um die Wartbarkeit des Codes zu gewährleisten. Also ein erster Schritt in die richtige Richtung. Im Nachfolgenden werde ich euch die Prinzipen „Don´t Repeat Yourself“ (DRY) und „Keep it Simple, Stupid“ (KISS) erläutern.

Grundlegende Dinge

Als erstes ist es wichtig, einheitliche Bezeichner zu wählen, ob für Klassen, Methoden oder Attribute. Dies ist sehr wichtig, weil Entwickler Code ca. zehn- bis fünfzehnmal öfter lesen als schreiben. Hat man bspw. eine Klasse Auto mit den Attributen attr1, attr2, … muss man den Code lesen und schauen, was nun diese Attribute darstellen sollen. Heißen die Attribute anstatt der oben genannten aber nun hersteller, typ, …, weiß man gleich was gemeint ist und kann den Code weiterlesen ohne einen Zwischenstopp einzulegen. Dies gilt aber wie oben schon erwähnt nicht nur für Attribute einer Klasse oder Methode, sondern auch für alle anderen Elemente, bspw. die Klassen und Methoden selbst. Darum ist es wichtig gründlich darüber nachzudenken wie man diese Elemente bezeichnet.

Ebenfalls ist es wichtig die Verständlichkeit von Methoden zu gewährleisten. Es soll eigentlich so sein, dass man sich eine Methode einmal durchliest und hinterher weiß, was in diese Methode genau geschieht. Deswegen sollten Methoden von der Größe her überschaubar bleiben. Methoden sollten ebenso immer nur eine Funktion erledigen. Ganz nach dem Prinzip „principle oft the least surprise“. Wenn ich also die Methode getCars() aufrufe, gehe ich davon aus, dass ich Autos bekomme und keine Pferde. Ebenfalls muss man davon ausgehen können, dass keine Seiteneffekte auftreten. Wie schreib ich denn nun meine Methode bzw. Methoden? „Clean Code“ besagt, dass man seine Funktionen folgender Maßen schreiben soll:

  1. „niladisch“ – Funktion ohne Übergabe von Parameter
  2. „monadisch“ – Funktion mit Übergabe eines Parameters
  3. „dyadisch“ – Funktion mit Übergabe mehrerer Paramater

und man für die Verständlichkeit nicht mehr als 2 Parameter in einer Methode verwenden soll.

Fazit: Bezeichnungen von Klassen, Methoden und Variablen durchdenken um das Lesen des Codes zu beschleunigen.

Kommen wir zu den Kommentaren. Sind diese überhaupt nötig? Der Code sollte so geschrieben sein, dass Kommentare nicht Not tun. Sind nun doch Kommentare nötig, sollten diese auch gut durchdacht sein. Unnötige oder sogar falsche Kommentare halten nämlich jeden Entwickler beim Lesen von Code auf. Grundsätzlich kann man Kommentare reduzieren, indem man Klassen, Methoden und Variablen gut durchdacht benennt. Man schreibt anstatt:

//Strecke in Kilometer
int distance = 0;
 
dies:
 
int distanceInKM = 0;

Somit wäre schon einmal dieser Kommentar nicht mehr nötig. Allgemein erkennt man an vielen Kommentaren, dass der Sinn und Zweck durch den Code nicht erkennbar ist und der Code schlecht geschrieben wurde. Sind die Kommentare auch noch an falscher Stelle, ist das der absolute Super-Gau ;) .

Fazit: Bei gut geschriebenem Code sind somit Kommentare überflüssig. Lediglich ein Kommentar im Header einer Klasse zu kurzen Klassenbeschreibung ist meiner Meinung nach eine feine Sache.

DRY – Don´t Repeat Yourself

Eines der wichtigsten und ältesten Prinzipien  von Clean Code ist DRY – Don´t Repeat YourselfWiederhole dich nicht. Dieses Prinzip besagt, dass man keine Dopplungen(Redundanzen) im Code haben soll bzw. ihn reduzieren soll. Leichter gesagt als getan, denn dieses „einfache“ Prinzip ist das meist missachtete in der Softwareentwicklung. Nichts ist nämlich leichter als Codeschnipsel zu kopieren und wieder einzufügen (Copy&Paste).  Dies ist nämlich gerad dann der Fall, wenn es schnell gehen soll. Dadurch entsteht Inkonsistenz und auch eine höhere Fehleranfälligkeit.

Fazit: Auslagerung von Funktionen in andere Klassen, um diese Funktion aus mehreren Stellen im Programm aufzurufen ist eine feine Sache.

KISS – Keep it Simple, Stupid

Dieses Prinzip besagt, dass man Problemlösungen, die man für andere erstellt, nicht unnötig verkomplizieren soll. Das deutschsprachige Sprichwort: „In der Kürze liegt die Würde“ ist ein Korrelat zu diesem Prinzip ;) .

Aber nicht falsch verstehen, dass Sprichwort: „In der Kürze liegt die Würze“ soll nicht aussagen, dass man den einfachsten, weil am unaufwändigsten Weg beschreiben soll! Vielmehr soll es darum gehen, dass man Dinge so einfach hält wie nur möglich, um im Späteren sich(oder auch einen anderen) nicht groß den Kopf zerbrechen muss, um zu verstehen was da genau passiert. Wenn man nach einiger Zeit auf seinen eigenen Code schaut und nicht mehr auf einen Blick versteht, was da passiert, sollte man sich Gedanken machen! ;)

Fazit: Problemlösungen so einfach wie möglich halten!

In meinen nächsten Artikeln werde ich noch einige interessante Prinzipien erklären, über die man stolpern wird auf dem Weg zum Clean-Code-Developer.


Jun 7 2011

Spannung mit dem 7805 regeln

Als ich mit der Microcontroller-Programmierung anfing, habe ich zuerst auf meinem STK500 programmiert und getestet. Aber nun habe ich ja auch das erste Programm außerhalb des STK500 zum Laufen bekommen. Als ich dann die Grundschaltung aufgebaut hatte, fiel mir auf, dass mein Programm aus irgendwelchen Gründen nicht lief :? . Spannung lag am Microcontroller an(+5V), auch an den einzelnen Pins, aber irgendwie war diese nicht stabil oder genug geglättet. Ich habe diese Spannung von meinem Trafo meiner Modelleisenbahn gezogen. Danach viel mir ein, dass ich die Spannung ja auch zum Testen von meinem STK500 abnehmen kann. Und siehe da, das Programm lief.

Nun habe ich mir eine Schaltung gebaut, die eine stabile und vor allem geglättete +5V Spannung liefert. Diese findet man auch ähnlich im Datenblatt des 78xx Spannungsreglers. Diese Schaltung sollte sich jeder merken, der sich mit Elektrotechnik beschäftigt, da es das 1×1 der Elektrotechnik ist. Man wird diese Schaltung als Elektrotechniker nicht nur einmal zusammenlöten ;) . Es gibt verschiedene Spannungsregler der 78-er Reihe. Die Zahl dahinter, gibt immer die Ausgangsspannung an, bspw.: 5V(7805), 8V(7808), 9V(7809), 12V(7812) und 24V(7824). Die Eingangsspannung muss um ca. 2V höher liegen, da der Spannungsregler auch versorgt werden muss. Man sagt die “optimale” Eingangsspannung des 7805 liegt zwischen 8 und 12 Volt. Bei viel höheren Spannungen wird schon sehr viel Energie in Form von Wärme abgegeben. Falls dies nicht anders möglich ist, muss man einen Kühlkörper an den Spannungsregler anbauen, sodass die Wärme gut abgeleitet werden kann. Bei niedrigerer Eingangsspannung bspw.: 5-7 wird der Spannungsregler keine stabilen 5V regeln können.

Die Schaltung schaut wie folgt aus:

Schaltung für einen Spannungsregler der Reiher 78XX

Spannungsreglerschaltung

Bauteile:

Der Spannungsregler ist dafür da, um, wie der Name schon sagt, die Spannung zu regeln. Dieser regelt die “hohe” Gleichspannung am Eingang zu einer kleineren stabilen Ausgangsspannung herunter. Die Kondensatoren sind dafür da, um die Spannung zu sieben und zu glätten. Es ist sehr wichtig, die Kondensatoren so dicht wie möglich an den Spannungsregler zu schließen, sodass sie auch ihre volle Wirkung entfalten können. Die stabilisierte Spannung kann man dann an Ua abnehmen. Zur Sicherheit kann man noch eine Diode einbauen.

Hoffe es hilft euch, also bei mir hat es wunderbar geklappt und ich habe nun eine stabilisierte Spannung für meinen Microcontroller. :)


Jun 3 2011

Counter 0-255 in C mit dem AVR-GCC Teil 2/2

…wie ja im letzten Artikel versprochen nun die Fortsetzung ;)

Ich habe mir ein LED- und Kohleschicht-Wiederstandssortiment gekauft und kann dies auch jedem, der mit der Elektrotechnik anfängt, oder auch schon dabei ist, empfehlen. Der große Vorteil ist, dass man alles auf einem Blick in einer Kiste hat, was Wiederstände und LEDs angeht ;) . Ich habe mir letztes Jahr 1.5kg Wiederstände gekauft, aber leider ist es immer keine einfache Sache den richtigen Wiederstand aus diesem “Wiederstandsknoll” zu finden.

Um den Microcontroller auf dem Experimentierboard zum Laufen zu bringen, muss man erstmal die Grundschaltung zusammenstecken. Die Grundschaltung besteht lediglich aus einer +5V Gleichspannung, einem 10kOhm Wiederstand ,einem 100nF Kondensator und sieht wie folgt aus:

Grundschaltung Atmega32Nachdem ich diese Schaltung nun zusammengesteckt habe, musste ich noch meine LEDs mit den Vorwiederständen (1kOhm) an die entsprechenden Ausgängen(PB0-PB7) und VCC verbinden. Die Schaltung hat sich nun um 8 LEDs mit jeweils einem Wiederstand erweitert.

Daraufhin habe ich nochmal alle Aus- und Eingänge geprüft, sodass ich sichergehen konnte, dass diese den Zustand haben, welchen ich erwartet haben. Nun war die Schaltung fertig aufgebaut und ich konnte den Zähler starten.
Meine Schaltung auf dem Experimentierboard sieht folgendermaßen aus:

Steckbrett Counter

Nun habe ich auch noch ein Video gemacht, hoffe die Qualität ist diesmal besser:

Wichtig ist dabei immer eine +5V stabilisierte und rauschfreie Gleichspannung zu verwenden. Falls dies nicht der Fall ist, läuft die Schaltung nicht. Wie man sich eine Schaltung baut, die genau diese +5V stabilisierte Gleichspannung liefert, erkläre ich in meinem nächsten Artikel.

Mein nächstes Projekt kommt bestimmt in den nächsten Tagen und ihr werdet es HIER als Erstes erfahren!

 


Mai 31 2011

Counter 0-255 in C mit dem AVR-GCC Teil 1/2

Nun habe ich mich durchgerungen und konnte endlich mal wieder was mit meinen uC´s(Microcontroller) machen. Ich habe mir ein Buch gekauft und hoffe, dass ich in der nächsten Zeit etwas mehr dazu komme. Das Buch heißt AVR-Mikrocontroller in C programmieren(Rezension folgt!). Damals habe ich schonmal etwas mit Atmels gemacht, aber leider dann den Faden verloren. Nun musste ich mir wieder alle Programme zusammensuchen und installieren.

Als erstes musste ich AVR Studio und PonyProg2000 auf meinem neuen Laptop(Windows 7 Prof. 64Bit) installieren, was sich schon als sehr kniffelig rausstellte. Die Programme im Internet zu finden ist die eine Sache, aber auch unterstützt für Win7 und 64Bit ist die andere. Als ich dann  eine Version gefunden habe, die ich installieren konnte, fand ich heraus, dass diese Version meinen Microcontroller nicht unterstützt. Nun habe ich eine Version gefunden, die auch meinen Controller unterstützt AVR Studio 4.18 .

Nachdem alles installiert war, ging es auch schon los. Ich habe mir dann erst mal vorgenommen einen Zähler zu bauen. Das ging auch relativ schnell. Ich habe angefangen mir das AVR-GCC-Tutorial von www.mikrocontroller.net durchzulesen. Damals habe ich schon mal etwas mit C gemacht und somit bin ich damit ziemlich gut zurecht gekommen. Nach ein paar Tests lief auch schon der Zähler mit folgendem Code:

// Counter
#include <avr/io.h>        //1
#include <util/delay.h>    //2
#define F_CPU 1000000l     //3
int main (void)            //4
{
 int i = 0;
 DDRB = 0xFF;              //5
 while(1) {                //6
  for(i = 255; i > 0; i--)
  {
   PORTB = i;              //7
   _delay_loop_2(100000);  //8
  }
  i=255;
  }
 return 1;                  //9
}
  • In der mit 1 markierten Zeile wird eine sogenannte Header-Datei eingebunden. In io.h sind die Registernamen definiert, die im späteren Verlauf genutzt werden.
  • Bei der 2 wird eine Datei eingebunden, die Wartemechanismen enthält.
  • 3 dort wird die Clock Frequenz definiert, wenn diese nicht im Makefile definiert ist.
  • Bei 4 beginnt das eigentliche Programm. Jedes C-Programm beginnt mit den Anweisungen in der Funktion main.
  • 5 Die Anschlüsse eines AVR werden zu einzelne Blöcke zusammengefasst, ein solcher Block wird als Port bezeichnet.  Mit DDRB =0xFF; werden die Anschlüsse des Blocks/Ports B als Ausgänge definiert.
  • In der Zeile 6 wird eine Endlosschleife begonnen, da der Zähler endlos laufen soll.
  • In der mit 7 markierten Zeile werden die Ausgangswerte eingestellt. Man kann einzelne Integer-Werte dem Port zuweisen, aber auch hexadezimale Blöcke wie PortB = 0xFF; . Da F=15(dezimal) bedeutet werden immer 2 Stellen angegeben, da pro Block 8 Anschlüsse vorhanden sind und 4 Bits maximal 15(dezimal) sind.
  • Bei 8 wird eine bestimmte Zeit gewartet. (dafür die importierte Datei)
  • 9 wäre das Programmende. Dieses wird aber nie erreicht, da es in der Endlosschleife verharrt.

Hier noch ein kleines Video in nicht der besten Quali, aber das nächste wird qualitativ besser. ;)

Der nächste Schritt ist nun, den Microcontroller mit 8 LEDs so zu verdrahten, dass auch der Zähler auf meinem Steckbrett läuft. Dazu muss ich mir aber erst mal ein paar einheitliche LEDs bestellen. Dies werde ich in den nächsten Tagen machen. Weitere Erkenntnisse und Bilder folgen im nächsten Artikel … :-)


Mrz 29 2011

MAD is ready 2use!

Endlich ist es soweit. Nach einigen Stunden/Tagen programmieren, einarbeiten in RCP, … habe ich MAD endlich “fertig” bekommen. MAD bedeutet MailAttachmentDownloader und ist ein Programm, dass Anhänge von E-Mails mit bestimmten Filterkriterien (bspw.: nur von Max Mustermann) herunterlädt.

Der Workflow des Programms ist wie folgt:

  • Verbindungsaufbau mit dem konfigurierten E-Mail Konto (POP/IMAP),
  • Anhänge der E-Mails herunterladen, die den konfigurierten Filtern entsprechen,
  • konfigurierte Flags der bearbeiteten E-Mails setzen (gelesen, löschen).

Die Konfiguration der einzelnen Konten und Filter werden in einer xml-Datei gespeichert. Die Konfiguration der Konten werden hauptsächlich über das Programm vorgenommen, sodass man von der xml-Datei und deren Inhalt gar nichts mitbekommt.

Ist die Konfiguration korrekt vorgenommen, kann man den Abruf nun manuell oder automatisch für ein oder mehrere Konten anstoßen. Wird der Abruf via manuell angestoßen werden die ausgewählten Konten nur einmal abgerufen. Wird das automatische Herunterladen gestartet, wird zuerst ein Zeitintervall abgefragt, in dem geprüft werden soll, ob neue E-Mails zum Abruf vorhanden sind. MAD kann man nun in den Tray verkleinern und es werden alle Aktionen im Hintergrund ausgeführt. Über das Tray Icon kann man MAD wieder aufrufen.

Das Programm steht unter der X11-Lizenz, die von mir angepasst und ins Programm integriert wurde. Somit ist es erlaubt MAD zu verwenden(natürlich nur für den privaten Gebrauch), aber der Quelltext ist nicht frei einsehbar. Wenn MAD kommerziell genutzt werden soll, schreib mir eine E-Mail und ich denke, dass wir eine Lösung finden.

Es gibt schon einige Versionen eines solchen Programms, leider noch keines, in dem man mehrere Konten mit mehreren Filtern konfigurieren und automatisch abrufen lassen kann .

Hier mal eine kleiner Einblick wie MAD aufgebaut ist:

MAD in wahrer Größe

MAD AccountView

 

Also links kann man seine Accounts auswählen und im rechten Teil sind die Datails der Konten einzutragen. Das ist natürlich noch nicht alles :) . Also falls ihr schon immer nach so einem Programm gesucht habt oder  Neugierig geworden seit, einfach downloaden, installieren und “losMADen” ;) . Eine kleine Installationsanleitung und Dokumentation findet ihr unter Projekte.

Falls euch Bugs oder Fehlfunktionen in MAD auffallen(was ich nicht hoffe), wäre ich euch sehr dankbar, wenn Ihr diese an mad@it-mike.de schicken würdet, sodass diese schnellstmöglich ausgeräumt werden können. Ebenfalls bitte ich euch bei Funktionswünschen eine E-Mail an die eben genannte E-Mail Adresse zu schicken. Ich freue mich über euer Feedback. :)

Download MAD

Download MAD Dokumentation


Jan 15 2011

Startschuss zum SCJP

So, nun ist es soweit. Ich fange endlich an mir so einige Sachen für den SCJP anzuschauen. Ich arbeite jetzt 1,5 Jahre mit Java und würde dies auch gern beibehalten. Deswegen habe ich mich entschieden noch dieses Jahr den SCJP zu machen. Wer noch nicht weiß was der SCJP ist, hier eine kurze Beschreibung: SCJP ist das Kürzel für Sun Certified Java Programmer und bedeutet, dass man nach dem Abschluss des Zertifikats, überwiegend gute bis sehr gute Kenntnisse im Bereich  der J2SE Programmierung hat, die einem helfen, noch performancereichere Softwareprodukte zu schreiben. Ebenfalls ist dieser Nachweis das Fundament für alle höherliegenden Zertifizierungen, bspw.: SCJD, SCDJWS, … . Ich habe mir das Buch SCJP – Sun Java Certified Programmer von Terence Gronowski aufgrund von Empfehlungen und guter Rezensionen im Netz besorgt. Als ich gestern das Buch mal etwas durchgestöbert habe, fand ich einige interessante Sachen, mit denen ich mich zwar schon einmal befasst habe, aber noch lange nicht so tiefgründig wie es in dem Buch passiert. Ich werde demnächst anfangen das Buch durchzuarbeiten und natürlich auch kleine knifflige Beispiele hier posten. Glaubt mir, es wird bestimmt spannend :)

http://www.amazon.de/SCJP-Programmer-Vorbereitung-6-Zertifizierung-CX-310-065/dp/3826659635

Jan 2 2011

Hallo Welt!

Hallo und herzlich Willkommen in meinem Blog.

Ich möchte euch hier einige Einblicke in meine Arbeit@Home, Probleme, … geben. Meine Artikel sollen sich hauptsächlich mit folgenden Themen befassen: Neuigkeiten, Java, Android, SQL, Sicherheit, Musik und Elektronik.

Danke und viel Spaß!