Kategorie-Archiv: Menschen

Fehler im Bewerbungsgespräch

Ich habe noch einen Fehler, den man in Bewerbungsgesprächen vermeiden sollte: wenn man in den Bewerbungsunterlagen wichtige Projekte aufführt (z.B. Diplomarbeit, Praktika oder auch Hobbyprojekte), dann sollte man auch etwas dazu erzählen können. Ich habe in den letzten Monaten mehrfach mit Bewerbern gesprochen, die noch nicht mal grundlegende Angaben zum Projekt machen konnten – z.B. was für eine Entwicklungsumgebung verwendet wurde. Und das zum Teil bei Projekten, die noch nicht mal drei Jahre in der Vergangenheit lagen.

Mir fallen dafür nur wenig schmeichelnde Erklärungen ein:

* Es war ein Gruppenprojekt und der Bewerber hat sich vom Team durchschleppen lassen, ohne selber einen nennenswerten Beitrag zu leisten.
* Das Projekt war nicht wirklich wichtig – eine kleine Nebensache, die man sich nicht merken muss.
* Der Bewerber ist unkonzentriert und hat ein sehr schlechtes Gedächtnis.

Sicher gibt es noch weitere – neutralere Erklärungen. Und wenn es das einzige Problem ist, dann ist das auch kein k.o. Kriterium. Aber es ist auf jeden Fall ein negativer Punkt, den man leicht vermeiden kann. Einfach zu Beginn der Bewerbungsphase noch mal die alten Unterlagen ansehen oder sich das Projekt anderweitig noch mal vor Augen führen. Falls das nicht klappt, würde ich mir überlegen, das Projekt ganz aus den Bewerbungsunterlagen zu streichen.

Management Mythen

Heute bin ich durch Zufall über einen älteren Blog Beitrag von Steven Sinofsky gestolpert: „Management Clichés That Work„. Da er auf diesem Gebiet als (ehemaliger) verantwortlicher Manager für Windows und Office viel Erfahrung haben sollte, habe ich den Beitrag natürlich gelesen. Ein paar Punkte daraus möchte ich hier aufgreifen.

Sinnvollerweise liest man erst den Beitrag von Steven Sinofsky. Anschließend geht es hier weiter…

Promise and deliver: Für den Teamleiter ist es wichtig, dass die Entwickler realistische Schätzungen abgeben. Deshalb bin ich genauso wie er der Meinung, dass die Masche “under promise and over deliver” (weniger zusagen als man leisten kann und am Ende des Projekts deshalb mehr abliefern als gefordert wurde) schlecht ist. Seine Begründung finde ich nur unzureichend. Das Problem bei dieser Vorgehensweise liegt für den Manager darin, dass er nur schlecht planen kann. Das Problem für den Entwickler wiegt noch schwerer: über fast die gesamte Projektlaufzeit wird er als wenig leistungsfähiger Mitarbeiter eingestuft. Die Erleichertung am Ende – „er hat ja doch einiges abgeliefert“ macht meiner Meinung nach die über längere Zeit aufgebaute Meinung nicht wett.

Richtig ist es (meiner Meinung nach), eine möglichst realistische Schätzung über die erreichbaren Ziele abzugeben. Gemeinsam mit einer Risikoabschätzung, was mindestens erreicht werden kann. Es ist die Aufgabe des Managers, sich Gedanken darüber zu machen, welche Zahlen nach außen kommuniziert werden. Dazu muss er aber möglichst realistische Zahlen haben. Wenn der Entwickler sich durch übermäßig hohe Sicherheitszuschläge vor Enttäuschungen schützen will, ist das unaufrichtig gegenüber der Firma und dem Team.

Diese Forderung funktioniert natürlich nur dann, wenn der Manager im Falle unerwarteter Probleme und nicht erreichter Ziele seine Verantwortung nicht einfach auf den Entwickler abschiebt. Er hatte die Zahlen und kannte die Risiken. Wenn er das nicht passend nach außen kommuniziert, muss er dafür auch selber die Verantwortung übernehmen.

Make sure bad news travels fast: dieser Punkt geht Hand in Hand mit dem bereits gesagten. Wenn die Schätzung aufgrund unerwarteter Gründe nicht aufgeht, dann muss man es auch so früh wie möglich kommunizieren. Nur dann hat der Manager die Möglichkeit Veränderungen vorzunehmen. Im schlimmsten Fall, dass der Releasetermin frühzeitig verschoben wird.

Für den Entwickler ist es hier wichtig, dass er sich nicht selber belügt. Der lustig gemeinte Satz „ein Softwareprojekt ist über 80% der Laufzeit fast fertig“ hat einen ernsten Hintergrund. Wenn ich nicht erkennen will, dass ich mit meinen Terminen im Verzug bin, kann ich es auch nicht weiterleiten. Mittelfristig ist so etwas für einen Entwickler ein ernsthaftes Karrierehindernis – er wird von seinem Manager ständig als Projektrisiko angesehen. Und dieses negative Gefühl überdeckt einen Teil der Leistungen.

Writing is thinking: es ist meiner Meinung nach offensichtlich, dass man beim Niederschreiben von Gedanken und Plänen gezwungen ist, tiefer über ein Problem nachzudenken. Wenn man einen Plan nur „im Kopf“ hat, kann man sich leichter selber beschummeln und offensichtliche Lücken leichter übersehen. Sobald man es schreibt, bekommt es eine andere Qualität. Damit ist nicht gemeint, dass man ständig umfangreiche Reports schreibt und nicht mehr zum Arbeiten kommt. Einfach in ein paar Sätzen die wichtigen Punkte aufschreiben und bei Bedarf noch ein paar Handskizzen reichen oft schon aus.

Noch besser ist es, wenn man es jemand anderen erklärt. Wenn ich es nicht erklären kann, habe ich es auch nicht verstanden. Damit ich es erklären kann, muss ich besser darüber nachdenken. Ich glaube, dass ein Teil des Erfolgs von Teamarbeit darin liegt, dass man seine Gedanken ständig erklären muss.

Practice transparency within your team: ein Softwareentwickler ist kein Einzelkämpfer in einer dunklen Höhle. Er ist ein Teamplayer – andere sind auf ihn angewiesen und er ist auf andere angewiesen. Und schon eine einzige Primadonna kann ein ganzes Team zerstören.

Don’t ask for information or reports unless they help those you ask to do their jobs: eine wichtige Aufgabe des Manager liegt darin, dafür zu sorgen, dass sein Team möglichst gute Arbeitsmöglichkeiten hat und somit die maximale Leistung bringen kann. Das ist keine reine Menschenfreundlichkeit sondern auch ganz egoistischer Selbstzweck. Ein egozentrischer Manager, der seine Eitelkeiten bedingungslos über sein gesamtes Team stellt, ist ein unfähiger Manager und gehört ausgetauscht.

Don’t keep two sets of books: den Vorgesetzten über den Projektfortschritt zu täuschen ist ein Verhalten, welches fast zwangsläufig zu Problemen führt. Ich glaube nicht, dass man das noch weiter erläutern muss.

Never vote on anything: hier bin ich abweichender Meinung. Vielleicht ist seine Einstellung auch der amerikanischen Eigenart geschuldet, dass man ein offenes Nein vermeiden sollte weil es unhöflich ist. Es gibt nun mal Situationen in denen alle Argumente ausgetauscht wurden, jeder hat die Position der anderen verstanden und trotzdem kommt man zu unterschiedlichen Ansichten. Hier kann es schon sinnvoll sein, einfach mal abzustimmen. Die Mehrheit hat nicht immer recht – aber wenn viele kluge Leute anderer Ansicht sind als ich es bin, dann ist es ein Grund, die eigene Position nochmal ernsthaft zu überdenken. Am Ende muss der Leiter entscheiden – er muss es schließlich auch verantworten.

When presenting the boss with n alternatives he/she will always choose option n+1: Autsch – das geht gegen die „pointy haired bosses„. Wenn der Vorgesetzte nicht in der Lage ist, die Möglichkeiten zu beurteilen, ist das eine Nothilfe. Ein normaler Manager möchte hier lieber eine ehrliche Liste der Möglichkeiten und Risiken haben. Niemand möchte gerne manipuliert werden, die Entwickler nicht – und die Manager auch nicht.

Products don’t ship with a list of features you thought you’d do but didn’t: wenn ein Feature so unwichtig ist, dass es ständig von anderen (neueren) wichtigen Features verdrängt wird, dann sollte man auch konsequent sein und es streichen. Sonst kommt man irgendwann in die Verlegenheit, dass man an unwichtigen Dingen arbeitet, „weil sie schon so lange da liegen“ – statt an den wichtigen Themen zu arbeiten. Es ist auch ehrlicher gegenüber dem Stakeholder dieses Features – lieber ein Ende mit Schrecken als ein Schrecken ohne Ende. Die Ausnahme hier: wenn es dem Einreicher mehr um persönliche Eitelkeiten als um das Produkt geht, kann es „humaner“ sein, den Featurewunsch in einer dunklen Ecken verschimmeln zu lassen als einen Grabenkrieg zu führen.

 

 

Programmier-Un-tugenden, die man vermeiden sollte

Gestern ist mir mal wieder unschöner Programm-Code über den Weg gelaufen. Das hat mich dazu animiert, mal die häufigsten Fehler aufzulisten, die ich immer mal wieder sehe und über die ich mich dauerhaft ärgern kann.

Dabei geht es mir noch nicht mal um irgendwelche abstrakten Programmiermodelle oder best practices im Architekturbereich. Es geht um kurze, alltäglich Codestücke, die man eigentlich nicht falsch machen kann. Und doch wird es gerne falsch gemacht. Es geht auch nicht um Syntaxfehler, die filtert der Compiler raus. Sondern einfach nur um schlechten Code, der irgendwie funktioniert.

1. Unklare Vorstellungen über boolsche Werte

Wenn ich solche Abschnitte sehe, stellen sich mir die Nackenhaare auf:

boolean isEnabled = myButton.getEnabled();

if (isEnabled == true) { ...

Die Variable isEnabled enthält einen boolschen Wert, die IF-Entscheidung erwartet einen. Warum dann noch diesen zusätzlichen Vergleich dazu packen. Damit sich der Compiler auch wirklich sicher ist, dass der Wert true ist? Und dann könnte man konsequenterweise doch auch „if ((isEnabled == true) != false)“ schreiben.

Mir signalisiert so eine Vorgehensweise, dass der Entwickler nur eine vage Vorstellung von boolschen Werten und ihrer Verwendung besitzt.

2. Überflüssige Kontrollstrukturen

Dieses Beispiel geht in die gleiche Richtung wie Beispiel 1.

boolean isEnabled = myButton.getEnabled();

if (isEnabled) {

  otherButton.setEnabled(true);

} else {

  otherButton.setEnabled(false);

}

Hier wird ohne nachvollziehbaren Grund eine komplette Kontrollstruktur aufgebaut. Dabei kann ich mich gar nicht über die verschenken Nanosekunden ärgern. Aber jeder andere Entwickler erwartet hier, dass etwas passiert, was schwergewichtiger ist als eine einfache Zuweisung: „otherButton.setEnabled(isEnabled)“.

Leider kommt dieser Fehler in der Praxis immer wieder vor. Auch hier liegt vermutlich oft einfach ein Defizit im Bereich „mal darüber nachdenken, was ich gerade mache“ vor.

3. Verdrehte Ausdrücke

Eines meiner Lieblingsaufreger, besonders gern von alten C Programmierern gemacht:

if ( 7 == anzahlWochentage) ...

Das liest sich einfach schlecht – Obi-Wan Kenobi Grammatik. Wenn man den Ausdruck umgangssprachlich formulieren würde, würde man sagen „Wenn die Anzahl der Wochentage gleich 7 ist“ und keinenfalls „Wenn 7 die Anzahl der Wochentage ist“. Auch wenn der Inhalt der gleiche ist, stolpert man über die falsche Reihenfolge, der Gedankenfluss wird gestört, die Aufmerksamkeit ist beeinträchtigt.

Die Herkunft dieses Anti-Patterns ist klar. Uralte C Compiler (älter als 30 Jahre), haben die Anwender leichtfüßig in Fehler der Art „if (anzahlWochentage = 7)…“ laufen lassen. Durch das vergessene zweite Gleichheitszeichen wird aus dem Vergleich eine Zuweisung. In der umgedrehten Schreibweise führt das zu einem Compilerfehler, da ein konstanter Wert nicht als Left-Value verwendet werden kann. Aber auch vor 30 Jahren gab es schon „lint“ für solche Probleme. Alle modernen Compiler werfen hier deutliche Warnings aus, so dass man diesen Fehler eigentlich nicht mehr machen kann.

Ein Entwickler, der sich dieser Schreibweise bemächtigt, löst bei mir schnell den Verdacht aus, dass er sich nicht um seine Warnings kümmert. Oder, dass er so viele Warnings hat, dass er sie gar nicht mehr kontrollieren kann. Beides ist schlecht, der Programmierer bewegt sich Haarscharf an der Grenze zum Chaos.

4. Magic Numbers

Die Verwendung von symbolischen Konstanten statt Zahlen im Quellcode ist mittlerweile fast überall Standard. In vielen Firmen gibt es Style Guides, die die Verwendung von Magic Numbers ausdrücklich verbieten.

Der Nutzen von Konstanten liegt auf der Hand. Wenn ich fünf Produktgruppen habe und im Programmcode alle Schleifen mit der Ziffer 5 laufen lasse, habe ich bei einer Erweiterung auf 6 Gruppen massiven Aufwand. Man kann ja nicht einfach per Suchen und Ersetzen alle 5 gegen eine 6 austauschen. Statt dessen muss man sich jede Verwendung genau darauf hin ansehen, ob die Zahl der Gruppen gemeint ist. Zudem gibt es weitere Verwendungen, der Index der letzten Gruppe beträgt 4 und nicht 5. Darauf muss man also auch achten.

Übel wird es, wenn ein Programmierer zwar den Wortlaut der Regel befolgt aber den Sinn nicht verstanden hat (oder nicht verstehen will). Dann kommen solche Konstruktionen vor:

const FIVE = 5;

...

for (var group = 0; group < FIVE; group++) ...

Der Wortlaut der Regel wurde befolgt, im Programmcode selber gibt es keine Magic Numbers. Aber das Ziel wurde verfehlt. Ich sehe der FIVE in der for Schleife nicht an, was für einen Zweck sie hat. Besonders übel wird es, wenn sich die Zahl der Gruppen auf 6 erhöht:

const FIVE = 6;

So eine Vorgehensweise kann man nur begrenzt mit Unfähigkeit begründen. Das grenzt schon an Sabotage.

5. Unsinnige Kommentare

Vernünftige Kommentare zu erstellen, ist nicht unbedingt einfach. In manchen Betrieben gibt es eine Festlegung, was kommentiert werden muss. Bei uns ist es z.B. so, dass alle public Methoden mit einem JavaDoc Header versehen werden müssen. Kommentare innerhalb einer Funktion sind aber kaum über einen Style Guide definierbar. Wenn man dann einfach einen bestimmten Prozentsatz von Kommentarzeilen fordert, entstehen solche Konstruktionen:

customers++;  // customer wird eins hochgezählt

Ein unglaublich blöder Kommentar, der genau das wiederholt, was der Programmcode ganz offensichtlich ausführt. Solche Kommentare sind nicht nur nutzlos. Sie sind sogar schädlich. Spätestens dann, wenn sich der Programmcode mal ändert und der nutzlose Kommentar nicht angepasst wird. Dann habe ich einen Widerspruch im Quellcode der schwere Irrtümer auslösen kann.

Kommentare sollten im Normalfall NICHT beschreiben, was passiert. Das wird durch den Programmcode am Besten beschrieben. Und wenn der schwer verständlich ist, dann sollte man sich lieber Gedanken über eine bessere Schreibweise statt über einen Kommentar machen.

Kommentare sollten beschreiben WARUM etwas passiert. Denn dieser Teil ist nicht aus dem Code abzuleiten. Vielleicht aus dem Kontext. Oder aus dem Pflichtenheft (liegt das fünf Jahre später noch in einer aktualisierten Form vor?).

Karrierefallen für Softwareentwickler

Durch meine Arbeit als Entwicklungsleiter führe ich natürlich auch eine größere Anzahl von Bewerbungsgesprächen durch. Dabei sieht man immer wieder bestimmte Muster, die einen Entwickler in eine Sackgasse führen. Ich kann natürlich nur über Probleme sprechen, die mir negativ auffallen. Aber ich vermute, dass diese Punkte auch bei anderen Firmen problematisch sind.

 

1. Falle – Unaufrichtige Bewerbungsunterlagen

Um es klar zu stellen – ich erwarte nicht, dass sich ein Bewerber in den Unterlagen selber schlecht macht. Und es ist legitim, sich in einem möglichst guten Licht darzustellen. Mit „unaufrichtig“ meine ich auch nicht gefälschte Zeugnisse. Das ist kriminell und muss nicht diskutiert werden.

Mit unaufrichtig meine ich stark übertriebene Fähigkeiten. Wenn ein Bewerber sehr gute SQL Kenntnisse angibt, dann erwarte ich zumindest ein solides Wissen über die Basics dieses Fachgebiets. In diesem Fall sollte man nicht mit der Frage „Was ist ein JOIN“ überfordert sein.

Eine Fehleinschätzung kann man durchaus akzeptieren. Wenn sich hier aber ein Muster abzeichnet und es in mehreren Gebieten massive Abweichungen in der Bewertung der Fähigkeiten ergibt, stellt sich mir die Frage, ob es der Bewerber allgemein nicht so genau mit der Wahrheit nimmt. Dann ist er für unsere Firma nicht geeignet.

Man muss nicht unbedingt bösen Willen unterstellen. Es kann ja sein, dass der Bewerber einfach nur ein wenig realistisches und überaus positives Selbstbild hat. Aber auch dann kommt er für eine Anstellung nicht in Frage. Ich hätte dann einen mittelmäßigen Angestellten, der ständig mit seinem Einkommen und seinen Karrieremöglichkeiten unzufrieden sein wird.

 

2. Falle – absterbende Nischen-Technologien

Es gibt auch heute noch eine große Anzahl von COBOL Arbeitsplätzen und als COBOL Entwickler wird man noch einige Zeit gutes Geld verdienen können. Ob es Spaß macht, ist eine andere Frage. Ich behaupte einfach mal, dass COBOL zwar ein absterbender Ast ist, aufgrund seiner weiten Verbreitung aber immer noch keine Nische ist.

Schwieriger wird es bei exotischeren Technologien, wie z.B. Mumps, Progress, Dataflex…

Wenn man in einem Betrieb nur mit so einer Umgebung arbeitet und dann den Job wechseln muss oder will, hat man ein kleines Problem. Daraus wird ein großes Problem, wenn man sich nicht zumindest privat mit anderen, moderneren Systemen auseinandergesetzt hat.

Natürlich kann man argumentieren, dass sich ein guter Entwickler in jede Programmiersprache (schnell) einarbeiten kann. Die Schwierigkeit liegt darin, dass ich im Bewerbungsgespräch kaum herausfinden kann, ob es sich um einen guten Entwickler handelt. Ein Jobangebot wäre mit einem hohen Risiko verbunden. Zudem finde ich persönlich einen Entwickler, der sich nur für die eine Programmiersprache im Job interessiert und nicht auch mal nach links und rechts schaut – nun ja, zumindest verdächtig.

 

3. Falle – Miniunternehmen oder one man shows

Ein Job als einziger Entwickler in einem Kleinstunternehmen direkt nach dem Studium kann durchaus reizvoll sein. Mangels Vergleichsmöglichkeiten ist man in der Firma der Held, der auf magische Art und Weise alle Probleme löst. Zumindest was das Thema Programmierung angeht, wird einem niemand in die Arbeit reinreden oder Vorschriften machen. Und man muss sich nicht für Fehler rechtfertigen, solange sie nicht allzu auffällig sind.

Das große Risiko dabei – man entwickelt sich nicht, oder zu langsam, weiter. Es gibt keine direkten Vorbilder, von denen man erfolgreiche Techniken erlernen könnte. Es gibt keinen Wettbewerb, keinen sozialen Druck, besseren Code zu schreiben.

Ich will damit nicht behaupten, dass man in so einer Position zwangsweise auf einem level mit begrenzten Fähigkeiten stehen bleibt. Aber das Risiko ist groß und ich habe es bei einigen Bewerbern so gesehen.

 

Fazit

Zu den Fallen 2 und 3 gibt es zum Glück einen Ausweg – man kann sich selber aktiv Weiterbilden. Im Internet nach best practices Ausschau halten, Tutorials lesen, in einem Open Source Projekt mitarbeiten. Wichtig ist die Interaktion mit anderen Menschen, anderen Denkweisen, anderen Vorgehensweisen. Das geht nur zum Teil während der regulären Arbeitszeit, zum Teil muss man es auch in der Freizeit machen. Das ist aber gut investierte Zeit in die Zukunft. Ein Entwickler ist nicht das Hollywood Klischee – er sitzt nicht 6 Monate im Keller um schließlich das revolutionäre Programm abzuliefern. Er muss mit anderen Menschen zusammenarbeiten und sich dabei selber auch weiterentwickeln.

Wenn man der Meinung ist, Computer sind nur während der Arbeitszeit ein Thema und in der Freizeit tabu, dann ist man in der IT Branche falsch. Schuhverkäufer wäre vielleicht eine Alternative. Aber möglicherweise muss man sich auch dort in der Freizeit über aktuelle Modetrends weiterbilden.

Zur Falle 1 gibt es einen einfacheren Ausweg: beim nächsten Mal eine realistischere Selbsteinschätzung und etwas mehr Ehrlichkeit.

 

Mein Technikblog

Auf dieser Seite wird in Kürze mein Technikblog entstehen. Hier schreibe ich über Themen wie Software Engineering, „große“ Hardware und meine Spielereien mit embedded Systemen.

Ziel ist es, dass jede Woche mindestens ein Beitrag zu finden ist.