Links der Woche

Gute Erklärung zu Dependency Injection

Veröffentlicht am 20.05.2019

Vor einiger Zeit musste ich lachen, als ich diesen Comic bei Geek&Poke zum Thema Dependency Injection gesehen habe: The Geek&Poke Pattern Weekend (Link: http://geek-and-poke.com/geekandpoke/2014/5/31/the-geekpoke-pattern-weekend). Ich stellte mir gleich die Frage, ob meine Auszubildenden wohl auch darüber lachen würden, also ob sie die Hintergründe des Comics verstehen.

Damals habe ich direkt diesen netten Artikel mit einem Leseauftrag an sie verschickt: An Absolute Beginner’s Tutorial on Dependency Inversion Principle, Inversion of Control and Dependency Injection (Link: http://www.codeproject.com/Articles/615139/An-Absolute-Beginners-Tutorial-on-Dependency-Inver). Dort werden wie der Titel schon andeutet die drei Begriffe Dependency Inversion, Inversion of Control und Dependency Injection erklärt und anhand eines Beispiels verdeutlicht.

Vor Kurzem hat mir mein Azubi dann noch diesen Artikel geschickt: Was ist eigentlich… Dependency Injection (DI)? (Link: http://blogs.msdn.com/b/dmx/archive/2014/10/14/was-ist-eigentlich-dependency-injection-di.aspx). Er erläutert den Begriff Dependency Injection noch ein wenig greifbarer, wie ich finde. Das Beispiel mit Gärtner, Lehrling und Schaufel ist gut nachvollziehbar.

In diesem Artikel wird noch einmal deutlich der Unterschied zwischen Dependency Inversion und Dependency Injection hervorgehoben und sehr ausführlich erklärt: Dependency Injection Is NOT The Same As The Dependency Inversion Principle (Link: https://lostechies.com/derickbailey/2011/09/22/dependency-injection-is-not-the-same-as-the-dependency-inversion-principle/).

Und zuletzt darf natürlich der Originalartikel vom „Erfinder“ Uncle Bob nicht fehlen: The Dependency Inversion Principle (Link: http://www.objectmentor.com/resources/articles/dip.pdf). Unabhängig von Ausbildungsstand und Programmiersprache in diesem Zusammenhang meine klare Empfehlung zur Lektüre von Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin) (Affiliate)*. Nicht unbedingt prüfungsrelevant, aber ein unverzichtbares Buch für eure Entwicklerpraxis. Dieses Buch hat mein Leben verändert (und enthält auch einen Abschnitt über Dependency Injection 😉 ).

Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)*

Falls ihr euch auf das Thema DI vorbereiten wollt, kann ich die obigen Links wärmstens empfehlen. Solltet ihr z.B. ein DI-Framework in eurem Abschlussprojekt verwenden (was insb. bei Java EE heute schon Standard ist), dann solltet ihr den Begriff auf jeden Fall im Fachgespräch erklären können. Nichts ist peinlicher als nicht zu wissen, mit welchen Werkzeugen man sein Projekt umgesetzt hat (und Punktabzug gibt es auch noch dafür).

Setzt ihr Dependency Injection bei eurer täglichen Arbeit ein? Wenn ja, „handgemacht“ oder mit einem Framework?

Was man als Softwareentwickler wissen muss

Veröffentlicht am 22.02.2019

In diesem Artikel stellt Javin Paul eine Liste mit 10 Dingen auf, die man seiner Meinung nach als Softwareentwickler/-in wissen muss: 10 Things Every Programmer and Software Engineer Should Know – DZone Open Source (Link: https://dzone.com/articles/10-things-every-programmer-and-software-engineer-s): Datenstrukturen und Algorithmen, Versionsverwaltung, Texteditoren, IDEs, Datenbanken und SQL, Linux, Excel, Programmiersprachen, Netzwerkgrundlagen, Skriptsprachen.

Falls du noch etwas auffrischen musst, kann ich dir für einige der Punkte die folgenden Ressourcen empfehlen.

  • Datenstrukturen und Algorithmen: A Common-Sense Guide to Data Structures and Algorithms: Level Up Your Core Programming Skills (English Edition) (Affiliate)*
    A Common-Sense Guide to Data Structures and Algorithms: Level Up Your Core Programming Skills (English Edition) (Affiliate)*
  • Versionsverwaltung: Einführung in die Versionsverwaltung mit Git (Teil 1) – Anwendungsentwickler-Podcast #76 (Link: /einfuehrung-in-die-versionsverwaltung-mit-git-teil-1-anwendungsentwickler-podcast-76)
  • Texteditoren: Drew Neil – Practical Vim, Second Edition: Edit Text at the Speed of Thought (Affiliate)*
    Drew Neil - Practical Vim, Second Edition: Edit Text at the Speed of Thought (Affiliate)*
  • Datenbanken und SQL: SQL – Häufige Fragen im Fachgespräch – Anwendungsentwickler-Podcast #19 (Link: /sql-haeufige-fragen-im-fachgespraech-anwendungsentwickler-podcast-19)
  • Linux: Der eigene Webserver (Teil 1) – Anwendungsentwickler-Podcast #88 (Link: /der-eigene-webserver-teil-1-anwendungsentwickler-podcast-88)
  • Programmiersprachen: Anwendungsentwickler-Podcast #12: Häufige Fragen im Fachgespräch – Programmierung (Teil 1) (Link: /anwendungsentwickler-podcast-12-haeufige-fragen-im-fachgespraech-programmierung-teil-1)
  • Netzwerkgrundlagen: Das ISO/OSI-Modell (Teil 1) – Anwendungsentwickler-Podcast #83 (Link: /das-iso-osi-modell-teil-1-anwendungsentwickler-podcast-83)

Ich bin die Liste mit meinen Azubis durchgegangen und wir konnten die meisten Punkte abhaken – spätestens am Ende der Ausbildung! 😉 Wie viele schaffst du?

Kommentare

  • Von Nina (Link: http://www.quazar.de/) am 23.04.2019
    Meine Nichte ist ein riesengroßer Fan von Computerspielen. Da sie nächstes Jahr Abitur macht, überlegt sie nun, ob sie ins Spieldesign oder in die Softwareentwicklung geht. Ich leite ihr mal diese Tipps weiter. Wenn sie sich hier durchklickt, weiß sie sicher besser, welches Studium ihr mehr liegt.
  • Von Stefan Macke am 23.04.2019
    Gerne, freut mich, wenn ich helfen kann! 🙂

Veganer (Milch-)Kaffee

Veröffentlicht am 20.02.2019

Mein Link der Woche hat heute ausnahmsweise einmal nichts mit Technik zu tun. Ich ernähre mich bereits seit einigen Monaten vegetarisch und möchte nun den nächsten Schritt gehen und meine Ernährung vegan gestalten. Die erste Hürde, die ich dabei nehmen muss, ist der allmorgendliche Kaffee auf der Arbeit. Den genieße ich nämlich seit Jahren mit einem ordentlichen Schuss Milch. Das ist in einer veganen Ernährung so nicht mehr möglich (und natürlich auch absolut in Ordnung so).

Auf dieser Website werden 10 verschiedene vegane Alternativen zu Kuhmilch vorgestellt, die man in den Kaffee geben kann: Milchalternativen im Test – Cappuccino mal ohne Kuhmilch (Link: https://www.coffeecircle.com/de/b/milchsorten-test).

Ich habe die meisten davon inzwischen selbst probiert und muss ehrlich sagen, dass sie mich überhaupt nicht überzeugt haben. Um nicht zu sagen: Der Kaffee schmeckte scheußlich! Aber bei der letzten Variante, die ich getestet habe, bin ich nun hängengeblieben: Sojamilch. Seit einigen Tagen trinke ich meinen Kaffee nun morgens mit Sojadrink anstatt Milch und ich muss sagen, dass ich mich geschmacklich sogar verbessert habe. Die Sojamilch bringt eine interessante Geschmacksnote mit und hat auch eine sehr cremige Konsistenz. Es fühlt sich fast an, als hätte man Sahne im Kaffee. Von meiner Seite aus spricht nun nichts mehr gegen den Verzicht auf Kuhmilch! 🙂

Bei Quarks & Co wurde vor Kurzem auch über Milchalternativen berichtet, die übrigens eine deutlich bessere Klimabilanz haben als Kuhmilch: Braucht Milch einen Ersatz? (Link: https://www1.wdr.de/mediathek/audio/wdr5/quarks/topthemen-aus-der-wissenschaft/audio-braucht-milch-einen-ersatz-100.html)

Spätestens damit sollte nun auch klar sein, was die Milchalternative auf einer Website für Softwareentwickler verloren hat. Denn ich denke, dass wir als Gesellschaft alle dafür verantwortlich sind, dass wir unseren Planeten noch ein paar Jahre nutzen können. In unserer IT-Branche gibt es seit langer Zeit die Idee, unsere Ressourcen bestmöglich zu nutzen. Ergebnisse sind z.B. virtuelle Maschinen oder aktuell die allgegenwärtigen Docker-Container. Wir tun alles, damit unsere stromfressenden Computer ihre Aufgaben effizienter erledigen. Warum also nicht auch in unserem Alltag das Problem der Ressourcenverschwendung angehen, wo wir einen viel größeren Effekt mit unserem Handeln erzielen können?

Wie ernährst du dich? Hältst du die nächtlichen Programmiersitzungen nur mit Energy Drinks und Chips durch, oder achtest du auf eine gesunde Ernährung? Bist du vielleicht sogar schon vegetarisch oder vegan unterwegs? Ich freue mich auf deinen Kommentar!

Kommentare

  • Von Broder Peters am 21.02.2019
    Hallo lieber Stefan, ich verfolge deinen Blog (und Podcast) bereits seit ein paar Jahren. Auf dich gestoßen bin ich damals zu Beginn meiner Ausbildung zum Anwendungsentwickler. Selbst nach meiner abgeschlossenen Ausbildung nutze ich gern deine Formate, um mein Wissen aufzufrischen oder Dinge zu lernen, die ich während der Ausbildung noch nicht verstanden habe. Nun aber zu deinem Text: Es hat mich sehr gefreut einen derartigen Beitrag zu lesen. Ich ernähre mich selbst seit einiger Zeit vegan und versuche in meinem Alltag so gut es geht bewusst zu leben. Ich stimme dir definitiv zu, dass die Verantwortung auch bei der Gesellschaft liegt und jeder bereits bei seinem Einkaufszettel etwas unternehmen kann. Für viele ist es allerdings eine Frage der Bequemlichkeit und Information. Besonders interessant fand ich deine Darstellung der IT in Bezug aufs Umweltbewusstsein, da ich ein paar Punkte noch nicht aus diesem Blickwinkel betrachtet habe. Ich versuche bei technischen Geräte, soweit möglich und sinnvoll, auf gebrauchte (und geprüfte!) Ware zurückzugreifen. Ich bin sehr gespannt, ob es in Zukunft ähnliche Themen hier geben wird, die uns zu einem ökologischeren und/oder sozialverträglicheren (Stichwort: Arbeitsbedingungen, Seltene Erden) Leben ermutigen. Bezüglich deines Kaffee Problems kann ich dir nicht direkt weiterhelfen, da ich selbst nur auf Leitungswasser, Mate und hin und wieder Tee zurückgreife. Allerdings ist seit einigen Monaten die Hafermilch von Oatly in der „Barista-Edition“ ziemlich bekannt geworden und soll sich gut für Kaffee eignen. Viele liebe Grüße und mach weiter so, Broder Peters

  • Von Stefan Macke am 21.02.2019
    Hallo Broder,

    vielen Dank für dein ausführliches Feedback! Freut mich, dass du mir schon so lange folgst! Wenn es sich ergibt, werde ich immer wieder mal andere Themen hier einstreuen.

    Die Hafermilch habe ich schon probiert und sie hat mir leider nicht so geschmeckt. Aber die Barista-Edition kenne ich noch nicht. Das werde ich nochmal ausprobieren! Danke für den Tipp! 😀

    Viele Grüße! Stefan

Die Mikado-Methode

Veröffentlicht am 07.12.2018

Von der Mikado-Methode habe ich schon öfter etwas gehört, mich aber bisher noch nicht so richtig damit beschäftigt. Mit diesem Artikel von David Tanzer hat sich das nun geändert: Legacy Code: The Mikado Method | David Tanzer – Coach Consultant Trainer (Link: https://www.davidtanzer.net/david%27s%20blog/legacy_code/2018/05/21/legacy-code-mikado-method.html).

Die Methode soll dabei helfen, What is Legacy Code? – Legacy Coder Podcast #5 (Link: https://serviceorientedarchitect.com/what-is-legacy-code-legacy-coder-podcast-5) Schritt für Schritt zu refaktorisieren. Im Prinzip zerlegt man seine Refactorings in kleinere Teilschritte und nutzt seine Versionsverwaltung, um bei Fehlern zurück zum lauffähigen letzten Stand zu gelangen.

Das Vorgehen kam mir sehr bekannt vor, weil ich es intuitiv schon genau so angewendet habe. Aber es einmal aufgeschrieben und mit einem eingängigen Namen versehen zu sehen, hilft mir, wenn ich das Vorgehen meinen Azubis erklären muss. Wie auch bei Design Patterns ist eine gemeinsame Sprache wichtig, um sich auf hohem Niveau verständlich austauschen zu können.

Kanntest du die Mikado-Methode schon oder hast sie vielleicht sogar schon einmal angewendet?

Kommentare

  • Von obgocnaovd (Link: http://oyewetvthe) am 28.07.2020
    Muchas gracias. ?Como puedo iniciar sesion?

Tipps zur Prüfung für Fachinformatiker Systemintegration

Veröffentlicht am 23.11.2018

Auf meiner Website und im Podcast gebe ich ja hauptsächlich konkretere Tipps zur Ausbildung von Anwendungsentwicklern. Viele Inhalte lassen sich aber 1-zu-1 auf die anderen IT-Berufe und insb. auf die Systemintegratoren übertragen. Janik Beck hat auf seiner Website nun einige Tipps für die IHK-Prüfung zusammengestellt, die sich direkt auf den FISI beziehen, z.B.:

  • Leitfaden für den Projektantrag als Fachinformatiker (Link: https://www.techbeck.com/leitfaden-projektantrag/)
  • Prüfungsvorbereitung: Ganzheitliche Aufgaben 1 (Link: https://www.techbeck.com/pruefungsvorbereitung-ganzheitliche-aufgaben-1/)
  • Leitfaden: Fachinformatiker – betriebliche Projektarbeit| www.techbeck.com (Link: https://www.techbeck.com/leitfaden-die-betriebliche-projektarbeit-dokumentation/)
  • Präsentation und Fachgespräch in der Abschlussprüfung als Fachinformatiker (Link: https://www.techbeck.com/pruefung-praesentation-und-fachgespraech/)

Die Inhalte werden mit zahlreichen Illustrationen angereichert und Literaturhinweise gibt es auch. Insbesondere die Liste der Themen für die schriftliche Prüfung gefällt mir gut. Wir haben gerade unseren ersten Ausbildung der ALTE OLDENBURGER in Vechta (Link: https://aosbildung.de/) zum Ausbildung Fachinformatiker/in für Systemintegration in Vechta (Link: https://aosbildung.de/informatik/fachinformatiker-systemintegration/) eingestellt und ab 2019 darf ich nun auch diesen ganzen Netzwerkquatsch vermitteln! 😉 Eine schöne Ergänzung zu meiner Mögliche Themen der Abschlussprüfung (Link: /moegliche-themen-der-abschlusspruefung).

Kennst du noch andere Ressourcen (z.B. Websites, Bücher usw.) rund um die Prüfungsvorbereitung oder Ausbildung zum FISI? Ich freue mich auf deinen Kommentar!

Kommentare

  • Von Alex am 01.01.2019
    Leider ist die Seite nicht erreichbar

Java-Bibliotheken zur Testunterstützung

Veröffentlicht am 09.11.2018

Mein Link der Woche bezieht sich dieses Mal auf meine eigene tägliche Arbeit. Ich arbeite viel mit Java und gehe dabei testgetrieben vor. Das heißt, Unit-Tests sind für mich absoluter Alltag. In diesem Artikel von InnoQ werden einige hilfreiche Bibliotheken vorgestellt, die mir das Leben als Entwickler einfacher machen: Java-Bibliotheken für den Einsatz in Tests — Testunterstützung (Link: https://www.innoq.com/de/articles/2018/10/java-test-libraries/). Ich setze zwar nicht alle davon ein, aber allein die Informationen über das Vorhandensein dieser Bibliotheken ist für mich für die Zukunft äußerst wichtig.

Falls ich z.B. asynchrone Operationen testen müsste, wüsste ich jetzt, dass es dafür eine passende Bibliothek gibt. Auch beim Test eines Logging-Frameworks, dass ich in so ziemlich jedem Projekt verwende, könnte ich mir Unterstützung holen. Auch der Java-Faker, der beliebige Testdaten auf Knopfdruck generiert, hat mir sehr gefallen. Vielleicht ist ja auch für dich noch das ein oder andere dabei.

Ich selbst nutze z.B. in fast jedem meiner Tests die Bibliothek GitHub – orien/bean-matchers: Hamcrest matchers for testing Java beans (Link: https://github.com/orien/bean-matchers). Damit kann ich mit wenigen Zeilen Code die komplette Funktionalität einer Java-Bean testen, also den Default Constructor, die hashCode()– und equals()-Methode und die Funktionalität aller Getter- und Setter-Methoden. Das erleichtert mir die Arbeit ungemein, da ich 100% Code Coverage mit ca. 10 Zeilen Testcode erreiche.

Hast du noch weitere Tipps für Bibliotheken, die uns beim Testen das Leben vereinfachen?

Die Bücher mit den meisten Markierungen

Veröffentlicht am 02.11.2018

Vor einiger Zeit habe ich diesen Artikel gefunden, in dem eine Analyse der Plattform Readwise vorgestellt wird, die die am meisten markierten eBooks ermittelt: What Books are Highlighted the Most Densely? (Link: https://blog.readwise.io/most-densely-highlighted-books-on-readwise/)

Von den Top 5 der Bücher habe ich zwei bereits als Hörbuch gehört (The Lean Startup: How Today’s Entrepreneurs Use Continuous Innovation to Create Radically Successful Businesses (Affiliate)* und Zero to One: Notes on Startups, or How to Build the Future (Affiliate)*). Die anderen kamen direkt auf die Wishlist! 🙂

Die Liste ist sehr interessant, da sie nur Bücher enthält, die von ihren Lesern als hilfreich bewertet wurden. Oder warum markiert man sich sonst Teile davon?

Wenn ich sie weiter durchschaue, finde ich auch viele weitere Bücher, die ich selbst gelesen oder gehört habe und definitiv weiterempfehlen kann (z.B. Deep Work: Rules for Focused Success in a Distracted World von Cal Newport bei Amazon (Affiliate)*).

Welche der genannten Bücher hast du selbst gelesen oder gehört? Welche kannst du weiterempfehlen? Welchen inspirierenden Inhalt hast du dir darin markiert?

Kommentare

  • Von mhatznghck (Link: http://rxehzaqacb) am 28.07.2020
    Muchas gracias. ?Como puedo iniciar sesion?

Verteilte Transaktionen

Veröffentlicht am 19.10.2018

Vor einigen Wochen war ich AOsbildung goes JFN @ Instagram (Link: https://www.instagram.com/p/BnqDPobn1UX/?taken-by=aosbildung) auf dem Java Forum Nord (Link: https://javaforumnord.de/site/2018/) in Hannover. Dort habe ich mir den Vortrag von Bernd Rücker zum Thema 3 common pitfalls in microservice integration and how to avoid them angeschaut. Eine etwas abgewandelte Version dieses Vortrags gibt es bei YouTube: Lost in transaction? by Bernd Rücker (Link: https://www.youtube.com/watch?v=Ikj59uEKhjg).

Ich kann den Vortrag absolut weiterempfehlen, da er viele Probleme anspricht, die verteilte Architekturen mit sich bringen. Im Detail geht es in dem YouTube-Video um verteilte Transaktionen. Dieses Problem hat man in „klassischen“ Monolithen nicht. Die ganze Welt setzt heutzutage scheinbar auf Microservices, wobei genau solche Probleme wie verteilte Transaktionen zu Beginn oft nicht berücksichtigt werden. Sie müssen dann mit viel Aufwand und sehr fehleranfällig nachimplementiert werden.

Also: Augen auf bei der Architektur-Wahl! Nur weil alle Anderen Microservices machen, muss das nicht die perfekte Lösung für die eigene Anwendung sein. Insbesondere wenn man überhaupt keine Ahnung von Problemen verteilter Anwendungen hat, die man definitiv mit der Einführung dieser Architektur bekommen wird.

Welche Architektur setzt ihr bei euren Anwendungen ein? Seid ihr schon im Microservice-Universum angekommen oder noch bei den guten alten Monolithen?

Continuous Documentation

Veröffentlicht am 12.10.2018

Ich persönlich nutze seit Jahren Markdown zum Schreiben meiner Texte. Auch diesen Beitrag habe ich mit Markdown erstellt, weil die Syntax so einfach ist und es für so ziemlich jede Plattform Plugins oder Editoren gibt, die Markdown unterstützen. Auf Fachkonferenzen zur Programmierung sehe ich aber aktuelle immer wieder Asciidoc als Standard für die automatisch generierte Dokumentation von Software. In diesem Artikel bei JAXEnter wird Asciidoc in Kombination mit Gradle und Eclipse als Tool zur Continuous Documentation vorgestellt: Technische Dokumentation mit AsciiDoc, Gradle und Eclipse (Link: https://jaxenter.de/asciidoc-gradle-eclipse-75169).

Dabei erzeugt das Build-Tool im Rahmen des Build-Prozesses automatisch eine menschenlesbare Dokumentation, z.B. in Form von HTML oder als PDF-Datei. Die Syntax von Asciidoc unterscheidet sich ein wenig von Markdown und wurde auch um zusätzliche Funktionen erweitert. Was für uns Entwickler am interessantesten sein dürfte, ist die Möglichkeit, UML-Diagramme in Textform zu definieren, die dann als hübsche Grafiken ausgegeben werden.

Ich selbst habe noch nicht mit Asciidoc gearbeitet, aber es rückt auf meiner To-Try-Liste immer weiter nach oben. 😉

Mit welchen Tools dokumentierst du deine Software? Ist die Dokumentation bei euch schon in den Build-Prozess integriert?

Preis für innovative Ausbildung der Nordwest-Zeitung

Veröffentlicht am 08.10.2018

Die Nordwest-Zeitung (NWZ) schreibt jedes Jahr den PIA 2018 (Link: https://www.nwzonline.de/pia) aus. Dieses Jahr haben sich meine Azubis mit unserem Projekt Ausbildung bei der ALTE OLDENBURGER (Link: https://aosbildung.de/) beworben. Den kompletten Artikel der NWZ gibt es hier: PIA: Azubis haben potenzielle Bewerber im Blick (Link: https://www.nwzonline.de/wirtschaft/vechta-pia-azubis-haben-potenzielle-bewerber-im-blick_a_50,2,2730776864.html).

Es lohnt sich definitiv, auch einen Blick auf die anderen Bewerbungen zu werfen. Es gibt viele spannende Projekte in den Unternehmen in unserer Region. Und auch kleine und mittlere Unternehmen können teilnehmen.

Letztes Jahr wurde ein Ausbildungskonzept in Teilzeit für alleinerziehende Mütter mit dem ersten Platz belohnt. Aber auch Social-Media-Hilfe für ältere Mitarbeiter durch Azubis oder eine unternehmensübergreifende Ausbildungswerkstatt wurden ausgezeichnet. Wir sind gespannt, ob wir dieses einen Platz auf dem Treppchen erreichen werden. Zur Sicherheit habe ich PIA-Wettbewerb: Komplexe Lerninhalte in Podcasts vermittelt (Link: https://www.nwzonline.de/wirtschaft/vechta-pia-wettbewerb-komplexe-lerninhalte_a_50,2,875956349.html) gleich mit eingereicht. 😉

Was macht ihr in deinem Unternehmen, um eine moderne Ausbildung zu gewährleisten?

Einführung in die funktionale Programmierung mit Java

Veröffentlicht am 05.10.2018

Aktuell vertiefe ich mit meinen Azubis das Thema funktionale Programmierung in Java. Dazu bin ich immer auf der Suche nach passender Einstiegsliteratur. Bei den Java Code Geeks gibt es eine nette vierteilige Einführung in den funktionalen Programmierstil mit Java und anderen Programmiersprachen: The Functional Style – Part 1 | Java Code Geeks – 2018 (Link: https://www.javacodegeeks.com/2018/08/functional-style-part-1.html).

Neben einer längeren theoretischen Einführung gibt es auch konkrete Code-Beispiele, die den Vorteil der etwas anderen Denkweise bei der Programmierung zeigen. Von Immutability über Tail Recursion bis zur Stream-Verarbeitung ist alles Wichtige angeschnitten.

Verwendest du bei deiner Programmierung auch schon den funktionalen Stil oder bist du noch „klassisch“ in der Objektorientierung unterwegs?

Verhaltensbezogene Fragen im Vorstellungsgespräch

Veröffentlicht am 03.10.2018

Aktuell führen wir bei uns in der Ausbildung bei der ALTE OLDENBURGER (Link: https://aosbildung.de/) die Vorstellungsgespräche zur Ausbildung zum Ausbildung Fachinformatiker/in für Anwendungsentwicklung in Vechta (Link: https://aosbildung.de/informatik/fachinformatiker-anwendungsentwicklung/). Dieses Jahr habe ich mir für die Gespräche einige Fragen zusammengestellt, um die Bewerber noch besser bewerten zu können. Dabei habe ich mich an Beispielen zu verhaltensbezogenen Fragen orientiert, anstatt die „Klassiker“ wie Stärken und Schwächen abzufragen, die meist nicht wirklich etwas Interessantes zutage fördern.

Beispiele für solche Fragen sind:

  • Wie gehen Sie mit stressigen Situationen um (z.B. parallele Klausuren)?
  • Wie gehen Sie mit Niederlagen um (z.B. einer schlechten Note)?
  • Wie arbeiten Sie sich in ein für Sie fremdes Thema ein?

Hier gibt es weitere Beispiele für verhaltensbezogene Fragen und auch eine gute allgemeine Einführung in das Thema:

  • Vorstellungsgespräche: mehr über die Azubis erfahren – ausbildernews (Link: https://www.ausbildernews.de/vorstellungsgespraeche-mehr-ueber-die-azubis-erfahren/)
  • How To Create A Simple Behavioral Interview Question | Manager Tools (Link: https://www.manager-tools.com/2008/06/how-to-create-a-simple-behavioral-interview-question)

Welche Fragen stellt ihr in Vorstellungsgesprächen bzw. welche wurden dir gestellt?

Grundkurs zum Thema Datenbanken und SQL

Veröffentlicht am 28.09.2018

Ich bin für meine Azubis immer auf der Suche nach guten Einführungsartikeln zu den „klassischen“ Themen der Anwendungsentwicklung, insb. zur Objektorientierung und zu Datenbanken. Aktuell gibt es bei entwickler.de (Link: https://entwickler.de) eine gute Artikelreihe zum Einstieg in letzteres Thema.

  1. Theorie des Datenbankentwurfs: Relationales Datenmodell, ER-Modell und Normalisierung (Link: https://entwickler.de/online/datenbanken/datenbanken-grundlagen-und-entwurf-115676.html)
  2. Kompakte Übersicht zu den Grundoperationen: Datenbankdefinition, Datensätze einfügen/ändern/löschen (Link: https://entwickler.de/online/datenbanken/grundkurs-datenbanken-datenbankdefinition-579858086.html)
  3. Erweiterte Techniken: Definition von Datensichten, Transaktion, Benutzer- und Sicherheitsaspekte umsetzen (Link: https://entwickler.de/online/development/datenbanken-sql-grundlagen-579858816.html)
  4. Verschiedene Datenbanksysteme im Überblick (Link: https://entwickler.de/online/datenbanken/grundkurs-datenbanken-datenbanksysteme-579859345.html)

Die Artikel von Dr. Veikko Krypczyk nutze ich schon seit einigen Jahren als Einführungsliteratur, aber bislang waren sie nicht kostenfrei und öffentlich zugänglich, sondern nur in gedruckter Form erhältlich. Die neue, überarbeitete Version gibt es nun komplett online.

Von der Modellierung mit Entity-Relationship-Model und Tabellenmodellen, über grundlegende SQL-Operationen (insb. natürlich SELECT), bis hin zu weiterführenden Bereichen wie Transaktionssteuerung und NoSQL werden alle wichtigen Themen rund um relationale Datenbanken angesprochen. Als alleiniges Lehrmittel oder gar für die Prüfungsvorbereitung reicht das natürlich noch nicht, aber die Artikelreihe gibt einen ersten Überblick und ist verständlich geschrieben.

Hast du Literaturempfehlungen zum Einstieg in Datenbanken? Womit hast du die DB-Modellierung und SQL-Abfragen gelernt?

Wie Entwickler mit Ablenkungen umgehen können

Veröffentlicht am 21.09.2018

Meinen Link der Woche klaue ich heute ganz dreist von meinem Azubi Vincent, durch den ich auf den Artikel aufmerksam geworden bin: For Programmers: How to Deal with Distractions and Interruptions (Link: https://www.javacodegeeks.com/2018/03/for-programmers-how-to-deal-with-distractions-and-interruptions.html). Er erläutert das grundsätzliche Problem, das wir Softwarentwickler mit Unterbrechungen haben: Wir brauchen einfach sehr lange, um nach einer Störung wieder produktiv arbeiten zu können, da wir viele Inhalte im Kopf haben müssen, um Code zu schreiben. Am besten wäre es, wenn wir einfach acht Stunden am Tag ungestört am Rechner arbeiten könnten.

Nein, das ist natürlich unrealistisch und auch nicht wünschenswert. Als Entwickler müssen wir selbstverständlich auch mit Kolleginnen sprechen, an Meetings teilnehmen, im Pair Programming arbeiten usw. Das Klischee des ITlers, der den ganzen Tag den Keller nicht verlässt, ist seit Jahren überholt (hoffentlich).

Aber trotzdem können wir einige Dinge tun, um im stressigen Alltag nicht auch noch zusätzlich unterbrochen zu werden. Dazu liefert der Artikel einige konkrete Tipps:

  • Kopfhörer aufsetzen
  • Handy und alle Notifications ausschalten
  • Arbeitszeiten geschickt wählen (sehr früh oder spät)
  • Auf Multitasking verzichten

Was tust du im Alltag gegen Unterbrechungen bei der Arbeit? Darfst du dich mit Kopfhörern „abschotten“? Oder habt ihr sogar „talk free hours“ im Büro?

Über die Identität von Entitäten

Veröffentlicht am 14.09.2018

Ich habe hier schon mehrere Artikel von Enterprise Craftsmanship – Software development principles and best practices (Link: https://enterprisecraftsmanship.com/) empfohlen, da er immer sehr interessante und vor allem allgemeingültige Themen diskutiert. Diese Woche kann ich seinen aktuellen Artikel Entity Identity vs Database Primary Key – Enterprise Craftsmanship (Link: https://enterprisecraftsmanship.com/2018/07/23/entity-identity-vs-database-primary-key/) dieser Liste hinzufügen.

Wenn du auch schon einmal die Anforderung hattest, Daten für deine Anwendung in einer Datenbank zu persistieren, wirst du dir vielleicht auch die Frage nach den zu verwendenden Schlüsseln gestellt haben. Objekte in deiner Programmiersprache brauchen eigentlich keine Schlüssel, da Beziehungen zu anderen Objekte über Objektreferenzen gelöst werden (z.B. hat ein Hund einfach ein Attribut herrchen vom Typ Mensch und nicht eine herrchenId vom Typ int). In der (relationalen) Datenbank werden dann aber Fremdschlüssel benötigt, um Datensätze, die diese Objekte repräsentieren, miteinander zu verknüpfen (in der Tabelle Hund gibt es eine Spalte herrchenId, die auf die Spalte id in der Tabelle Mensch zeigt). Dabei stellt sich nun die Frage, wie dies zu lösen ist.

Darüber hinaus gibt es im (aktuell sehr modernen) Ansatz des Domain-Driven Design: Tackling Complexity in the Heart of Software (Affiliate)* die Unterscheidung zwischen Value Objects und Entities, wobei letztere eine „Identität“ haben (z.B. der Mensch Stefan oder der Hund Wauzi) und erstere nicht (z.B. eine Portion Hundefutter, die durch jede beliebige andere Portion der gleichen Menge ausgetauscht werden könnte). Diese Konzepte gilt es ebenfalls mit der Persistenz in Einklang zu bringen.

Im genannten Artikel erklärt Vladimir noch einmal die obigen Fachbegriffe und gibt Hinweise, wie das Persistenzmodell gemeinsam mit Objektorientierung und Domain Driven Design funktionieren kann.

Falls du mit dem Domain Driven Design bisher noch nicht viel anfangen kannst, empfehle ich das Standardwerk von Eric Evans zum Einstieg: Domain-Driven Design: Tackling Complexity in the Heart of Software (Affiliate)*.

Domain-Driven Design: Tackling Complexity in the Heart of Software (Affiliate)*

Verwendest du in deinen Projekten DDD? Wie persistierst du deine Daten?

Java wird lizenzpflichtig

Veröffentlicht am 07.09.2018

Falls du Java-Entwickler/-in bist, hast du wahrscheinlich schon mitbekommen, dass Oracle die Lizenzbedingungen zum Einsatz von Java drastisch verändern wird. Bei uns im Unternehmen ist das aktuell ein wichtiges Thema, da es sein kann, dass wir ab Januar 2019 kommerzielle Lizenzen für den Produktionseinsatz von Java kaufen müssen. Und die sind nicht gerade günstig! Eine Alternative wäre der Umstieg auf das OpenJDK, das aber nicht von allen Herstellern unserer Fremdsoftware freigegeben ist.

Ich habe aus verschiedenen Blog-Artikeln und Veröffentlichungen von Oracle die wichtigsten Kernpunkte zusammengetragen. Solltet ihr das Thema in deinem Unternehmen noch nicht auf der Agenda haben, wird es definitiv Zeit. Ab Januar 2019 darf Java nicht mehr produktiv eingesetzt werden, ohne Lizenzen zu erwerben.

  • Ab Java 9 werden die Java-Versionen nur noch 6 Monate von Oracle mit Updates versorgt. Auch durch Lizenzen lässt sich diese Zeit nicht verlängern.
  • Alle 3 Jahre wird eine LTS-Version (long term support) veröffentlicht. Die erste wird Java 11 im Herbst 2018 sein.
  • LTS-Versionen bekommen Updates für 8 Jahre, aber nur mit Lizenzen.
  • Ab Januar 2019 darf das Oracle-JDK nur noch auf Entwicklung/QS eingesetzt werden. Für Produktion braucht man Lizenzen.
  • Für Privatnutzer wird Java 8 noch bis Dezember 2020 mit Updates versorgt.
  • JavaFX wird auf Java 8 bis 2022 mit Updates versorgt, wird ab Java 11 aber aus Java SE entfernt (-> Open Source).
  • Beispiel-Kosten der Lizenzen für 30 Server: 30 * 2 (CPUs) * 25$/Monat = 1.500$/Monat
  • Beispiel-Kosten der Lizenzen für 250 Clients: 250 * 2,5$/Monat = 625$/Monat

Hier kommen noch einige Links zum Thema:

  • Java Client Roadmap Update (Link: http://www.oracle.com/technetwork/java/javase/javaclientroadmapupdate2018mar-4414431.pdf)
  • Wird Java jetzt kostenpflichtig? | heise Developer (Link: https://www.heise.de/developer/artikel/Wird-Java-jetzt-kostenpflichtig-4144533.html)
  • Do I need to pay for Java now? (Link: https://dev.karakun.com/java/2018/06/25/java-releases.html)
  • Standard Edition (Java SE): OracleJDK und die Kommerzialisierung (Link: http://www.tutego.de/blog/javainsel/2018/08/standard-edition-java-se-oraclejdk-und-die-kommerzialisierung/)
  • IBM Supporting the Java Community (Link: https://developer.ibm.com/javasdk/2018/04/26/java-standard-edition-ibm-support-statement/)

Setzt ihr Java für eure Softwareentwicklung ein? Wie geht ihr mit der veränderten Lizenzsituation um? Ich würde mich über Feedback freuen.

Deutscher Personalwirtschaftspreis für den Anwendungsentwickler-Podcast

Veröffentlicht am 05.09.2018

Mein Anwendungsentwickler-Podcast wurde mit dem deutschen Personalwirtschaftspreis 2018 in der Kategorie Ausbildung ausgezeichnet! Ich konnte den dritten Platz erreichen. Und das immerhin neben so „großen“ Namen wie Dr. Oettker! Auf Platz 1 hat es die DPP2018 MACHER-VIDEO // Festo Gruppe (Link: https://www.youtube.com/watch?v=fIKnLnsd-U0) geschafft mit einem Konzept für die internationale Ausbildung von Nachwuchskräften.

Hier gibt es eine Liste aller Platzierungen: Spitzenreiter des Deutschen Personalwirtschaftspreises 2018 (Link: https://deutscher-personalwirtschaftspreis.de/spitzenreiter/).

Auch unsere Lokalzeitung, die Oldenburgische Volkszeitung, hat schon über den Podcast (und unsere Ausbildungs-Website Ausbildung bei der ALTE OLDENBURGER in Vechta (Link: https://aosbildung.de)) berichtet: Alte Oldenburger bildet mit Podcasts aus (Link: http://newsletter.oldenburgische-volkszeitung.de/alte-oldenburger-bildet-mit-podcasts-aus/).

Ich freue mich sehr darüber, dass meine (inzwischen jahrelange) Arbeit so gewürdigt wird! 😀

CEBIT 2018 - Die AOsbildung in Hannover

10.000 Schritte am Tag – oder doch nicht?

Veröffentlicht am 22.06.2018

Letzte Woche habe ich AOzubis und Stefan bei der CEBIT – Instagram (Link: https://www.instagram.com/p/Bj-j1NXnyKo/) im Rahmen der Ausbildung bei der ALTE OLDENBURGER – AOsbildung.de (Link: https://aosbildung.de) die CEBIT in Hannover besucht. Am Ende des Tages schauten sie auf ihre Smartwatches bzw. Smartphones und hatten über 15.000 Schritte gemacht. Es gibt ja aktuell die Idee, dass man mindestens 10.000 Schritte am Tag gehen sollte, um fit zu bleiben. Ich persönlich war nach dem Besuch der CEBIT ziemlich kaputt vom ganzen Herumlaufen. Und als ich dann die Anzahl der Schritte hörte war ich doch überrascht, dass es „nur“ so wenig waren. Da musste ich gleich an diesen Artikel hier denken, der die 10.000 Schritte etwas in Frage stellt: Michael Mosley: ‚Forget walking 10,000 steps a day‘ – BBC News (Link: https://www.bbc.com/news/health-42864061).

So three short brisk walks were easier to fit into the day and better for health. I thought that was really interesting and I found it very encouraging, because I really don’t like doing 10,000 steps.

Laut einer Studie reicht es aus, dreimal am Tag für 10 Minuten einen Spaziergang zu machen, um damit sogar deutlich bessere Effekte für die Gesundheit zu produzieren, als wenn man einmal am Tag einen „Gewaltmarsch“ durchführt. Aber welche Variante für dich besser ist, kannst du wohl nur selbst entscheiden.

Übrigens: Das neue Konzept der CEBIT ist durchaus interessant. Der Charakter einer Konferenz bzw. eher sogar eines Festivals oder Jahrmarkts (SAP hatte ein Riesenrad aufgebaut) fand insbesondere bei meinen jungen Kollegen durchaus Anklang.

CEBIT 2018 - Festival Stage

CEBIT 2018 - Riesenrad von SAP

Ich persönlich konnte fachlich allerdings wenig von der Konferenz mitnehmen. Die im Vorfeld groß angekündigten Vorträge fand ich sehr oberflächlich und die deutlich kleinere Ausstellung bot mir auch nicht allzu viel Interessantes. Für einen Tagesausflug mit den Azubis werde ich gerne wieder nach Hannover fahren, aber einen fachlichen Mehrwert bot mir die Konferenz leider nicht.

Hast du dir auch ein Ziel gesetzt, wie viele Schritte du am Tag gehen willst? Oder warst du auf der CEBIT? Ich freue mich auf deinen Kommentar!

Wie man bei der Entwicklung eines Computerspiels scheitern kann

Veröffentlicht am 29.09.2017

Ich bin regelmäßiger Leser des Blogs von Vladimir Khorikov. Seitdem ich seine Pluralsight-Kurse über DDD und funktionale Programmierung gesehen habe, verfolge ich seine immer wieder lehrreichen und gut geschriebenen Artikel. In einer umfangreichen Artikelreihe schildert er hier, wie er bei der Entwicklung eines Browser-Spiels scheiterte: A story about how I tried to get into game development and failed (Link: http://enterprisecraftsmanship.com/2017/07/17/a-story-about-how-i-tried-to-get-into-game-development-and-failed/).

Ich fand es sehr spannend zu lesen, worauf man bei der Entwicklung eines scheinbar simplen Browser-Spiels achten muss und welche technischen Herausforderungen sich ergeben, wenn das Spielerlebnis trotz Latenz flüssig sein soll. Sein Partner und er haben viel Zeit investiert (über ein halbes Jahr) und sind ihrer Meinung nach trotzdem gescheitert. Und das hauptsächlich aufgrund technischer Probleme. So einfach ist die Entwicklung eines Spiels also scheinbar auch heutzutage noch nicht.

Das Spiel ist aber tatsächlich online gegangen: bist.io (Link: http://bist.io/). Hier gibt es auch ein YouTube-Video eines Kampfes: Bist.io epic battle (Link: https://www.youtube.com/watch?v=gG4yCG08DIw). Für einen „Fehlschlag“ sieht das schon ziemlich gut aus! 🙂

Hast du auch schonmal versucht, ein Spiel zu entwickeln? Oder arbeitest du sogar für einen Spieleentwickler? Ich freue mich auf deinen Erfahrungsbericht.

Kommentare

  • Von Marcel am 29.09.2017
    Ich entwickle zu privaten Zwecken ein wirtschaftsanalysetool für ein Onlinespiel. 🙂 Früher alsKind hab ich öfter mal kleine Spiele entwickelt, wie 4 Gewinnt mit Computergegner oder einen Spielautomaten ( einarmiger Bandit ). Am Amiga und PC sowas wie Brackout und eine Mensch-Ärgere-Dich-Nicht Variante am C64 mit Schiffen die sich gegenseitig versenken. Ich liebe es Grafiken zu Programmieren und verfalle gern in Details.

  • Von Stefan Macke am 01.10.2017
    Ja, die Grafikprogrammierung ist bestimmt spannender als das x-te DB-Backend! 🙂 Aber die Jobs in der Spielebranche sind leider nicht so breit gestreut und dann natürlich auch heiß begehrt.

  • Von Marcel am 02.10.2017
    Was mich brennend interessieren würde sind so rechtliche Aspekte. Ich lese ja die Daten aus einer Spielwebseite aus. Im Grunde kann es dem Betreiber egal sein aber wo Geld durch Anwälte gedruckt werden kann, muss man höllisch aufpassen. Ich wende die Technik über Cross-Domain an. In der Seite wird JavaScript über das Broswerplugin Tempermonkey ausgeführt und die interessanten Daten werden an eine andere URL meines Server über HTTPS weitergeleitet. Das alles geschieht nur durch das reine benutzen der Seite ohne zus. Trafficlast. Alles andere passiert dann auf Basis von PHP, MySQL und Clientseitig gibts eine extra Anwendung die nur über den eigenen Dienst läuft. Interessant ist das Ganze dann im Verbund mehrerer Spielern. 🙂 Ich glaub aber das werd ich alles ins Darknet auslagern und mit Bitcoins finanzieren, wenns mal läuft. Selbst als harmloser Blogbetreiber ist man immer einen Schritt weit zum Bankrott entfernt, wenn man sich den falschen Juristen einfängt. Wir sind heute schon soweit, das man etwas juristisch stehlen kann, was die Menschheit einmal voranbrachte. Der Austausch von Ideen. Ich hab privat schon alles fallen lassen was ich an öffentlichen Web-Projekte erstellt hab. Die EU ( deren Lobby ) plant ja nun Open-Source den gar aus zu machen. Aber ich schweife ab .. xD

Wie viel Aufwand erzeugt ein Konferenzvortrag?

Veröffentlicht am 14.07.2017

Die Projektpräsentation in der IHK-Abschlussprüfung ist eine gute Vorbereitung auf den späteren Alltag als Softwareentwickler. Häufig muss man Kunden technische Lösungen präsentieren oder mit Kollegen die Architektur der eigenen Anwendung abstimmen. Aber auch auf Konferenzen oder User Groups bekommt man die Möglichkeit, sein Wissen mit interessierten Zuschauern zu teilen. Ich kann nur jedem Prüfling dazu raten, Letzteres selbst einmal auszuprobieren. Allerdings sollte man den Aufwand, der für eine vernünftige Präsentation nötig ist, nicht unterschätzen – analog zur IHK-Prüfung 😉

In diesem umfangreichen Artikel zeigt Hynek Schlawack wie aufwändig die Vorbereitung seiner eigenen Konferenzvorträge ist: On Conference Speaking · Hynek Schlawack (Link: https://hynek.me/articles/speaking/). Er zeichnet ein realistisches Bild seines Prozesses und spricht ehrlich über seine Ängste und seine Strategien, um einen möglichst effektiven Vortrag zu halten.

Seine Schilderungen haben mich motiviert, erneut Vorschläge für Konferenzen im nächsten Jahr einzureichen. Auch wenn ich aus eigener Erfahrung bestätigen kann, dass diese Präsentationen sehr anstrengend sind, ist das Gefühl, wenn der erfolgreiche Vortrag abgeschlossen ist, doch sehr befriedigend. Und ganz nebenbei muss man sein Thema auch noch richtig intensiv lernen. Wie man so schön sagt: Lehrer lernen doppelt!

Hast du selbst schon Vorträge auf User Groups oder gar Konferenzen gehalten? Was sind deine Erfahrungen mit dem Sprechen vor Menschen?

Serverless Architecture bzw. Function as a Service

Serverless Architecture bzw. Function as a Service

Veröffentlicht am 07.07.2017

In dieser spannenden Artikelserie beschreibt Oliver Wronka, wie er eine bestehende Java-Applikation mit Spring Boot (Link: https://projects.spring.io/spring-boot/) nach AWS Lambda | Produktdetails (Link: https://aws.amazon.com/de/lambda/details/) migriert: Ist AWS Lambda das bessere Spring Boot? (Link: https://jaxenter.de/aws-lambda-spring-boot-55160)

Das Thema Serverless Computing oder auch Function as a Service (Faas) ist aktuell das absolute Hypethema. Man hat das Gefühl, dass Microservices schon wieder total out sind, weil jeder heute nur noch separate Funktionen in der Cloud entwickelt. Was liegt da näher, als einen Migrationsleitfaden für Microservices (die man in Java sehr schön mit Spring Boot umsetzen kann) hin zu einer serverlosen Architektur (in diesem Fall mit AWS Lambda, das im Gegensatz zu Azure Functions – serverlose Architektur | Microsoft Azure (Link: https://azure.microsoft.com/de-de/services/functions/) auch Java anbietet) zu schreiben? 😉

Auch wenn man weder Spring Boot kennt, noch Java entwickelt, kann ich die Artikelserie weiterempfehlen, da sie gut nachvollziehbar die Möglichkeiten der Amazon-Plattform zeigt und auch den Sinn des serverless-Ansatzes verdeutlicht. Ich selbst habe zwar (noch) keinen Anwendungsfall für FaaS, kann aber nachvollziehen, warum er für einige Unternehmen wirklich sinnvoll sein kann.

Jetzt ist es bestimmt nur noch eine Frage der Zeit, bis FaaS auch in der IHK-Prüfung abgefragt wird! 😉

Hast du schon mit Cloud-Diensten wie AWS Lambda oder Azure Functions gearbeitet? Wofür setzt du FaaS ein?

Kommentare

  • Von nlxjajknac (Link: http://pxvtcebxri) am 25.07.2020
    Muchas gracias. ?Como puedo iniciar sesion?

Tipps zu Vorträgen

Angst vor Vorträgen? Mach es einfach!

Veröffentlicht am 26.05.2017

Ein wichter Teil der IHK-Abschlussprüfung ist die Projektpräsentation. Und viele Prüflinge meistern diesen Teil auch sehr gut. Man spürt die Freude an der Programmierung und sie brennen für ihr Thema. Da wäre es doch schade, wenn es in diesem Bereich nach der Prüfung nicht weitergehen würde. Wenn du selbst Spaß am Vorträgen vor Publikum hast, dann schau dir doch einmal diese Liste mit Tipps dazu an: Vorträge halten – 6 Tipps, wie man damit anfängt | entwickler.de (Link: https://entwickler.de/online/development/vortraege-halten-579794266.html).

Es gibt auch für Azubis oder gerade fertige Anwendungsentwickler viele Möglichkeiten, Präsentationen zu spannenden Themen zu halten. Sei es in lokalen User-Groups (z.B. beim Softwareentwickler-Stammtisch (Link: http://softwareentwicklerstammtisch.de)) oder einfach vor den Kollegen im eigenen Unternehmen. Viele Softwareentwickler lassen sich gerne über neue Technologien informieren oder freuen sich über Erfahrungsberichte anderer Programmierer. Biete doch einfach einmal an, dass du nach eurer nächsten Entwicklerbesprechung einen kurzen Vortrag hältst. Dabei kannst du diesen wichtigen Soft-Skill trainieren und gleichzeitig auch noch deinen Kollegen etwas Gutes tun.

Wenn du noch einen Schritt weiter gehen willst, schau dir einfach einmal die „Call for Presentations“ verschiedener Konferenzen an (z.B. den der Softwareentwicklung im Mittelstand – SEROM (Link: https://serom.de). Die JavaLand hat z.B. einen eigenen JavaLand (Link: https://www.javaland.eu), der sich explizit an unerfahrene Sprecher richtet. Dort wird dir sogar ein Mentor zur Seite gestellt, der dich auf den Vortrag vorbereitet. Besser kann der Einstieg doch gar nicht laufen!

Auch für dich persönlich springt beim Vortragen etwas raus: Du lernst deinen Inhalt wirklich gut! Denn die Motivation zu lernen ist eine ganz andere, wenn du weißt, dass du dein Wissen vortragen musst. Und die Fragen, die deine Zuhörer ggfs. stellen, bringen dich auf neue Ideen und geben dir Denkanstöße für eine weitere Vertiefung.

Hast du auch schon bei User-Groups oder auf Konferenzen gesprochen? Was sind deine Erfahrungen? Poste gerne einen Link zu deinen Slides als Kommentar!

Was ist wartbarer Code?

Wie man unwartbaren Code schreibt

Veröffentlicht am 28.04.2017

Eine wichtige Eigenschaft, die guter Code haben sollte, ist Wartbarkeit. Doch was verbirgt sich eigentlich hinter diesem Begriff? Was macht Code wartbar? Oder andersherum: Woran erkennt man, dass Code nicht wartbar ist?

Eine schöne Liste mit Dingen, die man in seinem Code besser nicht tun sollte, bietet GitHub – Droogans/unmaintainable-code: A more maintainable, easier to share version of the infamous http://mindprod.com/jgloss/unmain.html (Link: https://github.com/Droogans/unmaintainable-code). Der umfangreiche Artikel ist bewusst aus der Sicht eines Programmierers geschrieben, der schlechten Code schreiben möchte. Wie bekomme ich es hin, dass mein Code möglichst unwartbar wird?

Ein paar Klassiker von der Liste sind zum Beispiel:

  • Variablennamen aus einem Buchstaben
  • Akronyme noch und nöcher
  • dieVerwendung globaler Variablen
  • Ungarische Notation
  • Verwendung von kryptischen Makros

Ich fand den Artikel äußerst unterhaltsam und ganz nebenbei lernt man auch noch, warum bestimmte Dinge in wartbarem Code nichts verloren haben. Der Gegenentwurf zum Artikel ist sicherlich Robert C. Martin – Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*, das du hoffentlich schon gelesen hast! Wenn nicht, wäre es dringend an der Zeit für einen neuen Buchclub! 🙂

Robert C. Martin - Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*

Welche „Sünden“ von der Liste hast du bereits begangen? Achtest du bei deiner täglichen Arbeit darauf, wartbaren Code zu schreiben?

Design-Tipps für PowerPoint-Präsentationen

Design-Tipps für PowerPoint-Präsentationen

Veröffentlicht am 31.03.2017

Wenn du mir schon länger folgst, weißt du, dass die Projektpräsentation mein Lieblingsthema ist. Ich mag langweilige Textfolien mit immer gleichem Aufbau und Inhalt nicht und bin der Meinung, dass auch die IHK-Abschlusspräsentation spannend gestaltet werden kann. Beispiele für Projektarbeiten (Anträge, Dokumentationen, Präsentationen) auf dieser Seite beweisen, dass ich mit dieser Annahme durchaus richtig liege.

In diesem kurzen Artikel hat Meg Miller einige Tipps von Designern zum Erstellen ansprechender (PowerPoint-)Präsentationen zusammengetragen: 5 Top Designers On How To Create The Ultimate PowerPoint Presentation | Co.Design | business + design (Link: https://www.fastcodesign.com/3064783/5-top-designers-on-how-to-create-the-ultimate-powerpoint-presentation). Ich glaube, dass auch Prüflinge sich einiges davon zu Herzen nehmen sollten.

  • Erarbeite ein Storyboard: Eine Präsentation braucht einen roten Faden. Den bekommt man Foliennummern bzw. Seitenzahlen gehören auf jede Folie! – Mythen der Projektpräsentation (Link: /foliennummern-bzw-seitenzahlen-gehoeren-auf-jede-folie-mythen-der-projektpraesentation) hin, sondern indem man sich vor der Erstellung der Folien Gedanken zum Aufbau und Ablauf der Präsentation macht.
  • Präsentiere visuell statt textuell: Textfolien sollten der Vergangenheit angehören. Technische Inhalte kann man nicht mit Bildern illustrieren – Mythen der Projektpräsentation (Link: /technische-inhalte-kann-man-nicht-mit-bildern-illustrieren-mythen-der-projektpraesentation) kann man sehr gut visuell präsentieren.
  • Lege den Fokus auf das Wesentliche: Verliere dich nicht in Details, sondern fasse die Kernpunkte deines Projekts kurz und gut verständlich zusammen.
  • Verwende individuelle Darstellungen und keine Standardfolien: PowerPoint-Vorlagen sind der Tod deiner Kreativität. Corporate Design ist Pflicht – Mythen der Projektpräsentation (Link: /mythen-der-projektpraesentation-corporate-design-ist-pflicht) und andere (langweilige) Standardinhalte.

Was sagst du zu den obigen Anregungen? Wirst du sie in die Tat umsetzen?

Type-First Development

Type-First Development

Veröffentlicht am 17.03.2017

Ich schaue immer gerne, wie man in anderen Programmiersprachen idiomatisch Software entwickelt. Dieser Artikel von Tomas Petricek ist ein gutes Beispiel für ein mögliches Vorgehen in F#: Why type-first development matters – Tomas Petricek (Link: http://tomasp.net/blog/type-first-development.aspx/) (danke an Markus Amshove (Link: https://amshove.org/) für den Link-Tipp).

F# ist eine funktionale Programmiersprache auf der Common Language Runtime – Wikipedia (Link: https://de.wikipedia.org/wiki/Common_Language_Runtime) und bietet dem Entwickler viele „Kleinigkeiten“ an, die ihm das Leben einfacher machen. So gibt es z.B. die „Units of Measure“, mit denen man Zahlen eine Einheit – analog zu den z.B. aus dem Physikunterricht bekannten – geben kann. Eine Entfernung in Kilometern könnte z.B. so definiert werden: Distance : float<km>. Das hätte dem Mars Climate Orbiter: Absturz wegen Leichtsinnsfehler beim Rechnen – SPIEGEL ONLINE (Link: http://www.spiegel.de/wissenschaft/mensch/mars-climate-orbiter-absturz-wegen-leichtsinnsfehler-beim-rechnen-a-44777.html) wahrscheinlich das Leben gerettet 😉

Tomas beschreibt in seinem Artikel darüber hinaus aber ein ganzes Vorgehensmodell bei der Softwareentwicklung: Type-First Development. So nennt er den Fokus auf die Entwicklung des Datenmodells vor der Umsetzung der Programmlogik. Viele Denk- oder Verständnisfehler können dabei schon zu Beginn des Projekts verhindert werden, da man sich zunächst auf das Kernmodell der Domäne verständigen muss – und das sogar „typsicher“. Außerdem verhindert das vorgegebene Datenmodell einige spätere Fehler, da analog zur statischen Typisierung bestimmte Dinge bei der Programmierung einfach nicht mehr möglich sind.

Sicherlich bieten F# und andere funktionale Sprachen viele nützliche Konzepte, um das TFD umzusetzen, aber ich denke, das Vorgehen ist ohne Weiteres auch auf die eigene – wahrscheinlich objektorientierte – Sprache übertragbar. Es geht eher um die Denk- und Herangehensweise bei der Problemlösung. Deswegen finde ich den Artikel auch sehr spannend: er regt mich zum Nachdenken über meine eigene Programmierung an.

Was hältst du von der Idee des TFD? Arbeitest du vielleicht sogar schon mit einer funktionalen Programmiersprache?

Pair Programming

Pair Programming

Veröffentlicht am 10.02.2017

Heute ist mein Link der Woche ein ganz besonderer Artikel. Mein Azubi Jonas hat nämlich seinen eigenen Blog gestartet und – im Rahmen seiner Ausbildung zum Fachinformatiker Anwendungsentwicklung – seinen ersten Fachartikel geschrieben. Das Thema ist Pair Programming (Link: https://blog.jonas-hellmann.de/pair-programming/).

Meine Azubis haben in den letzten Wochen einige gemeinsame Programmiersitzungen durchgeführt und Jonas hat seine Erfahrungen daraus, aber auch einige allgemeine Tipps und Erläuterungen zum Thema in einem kurzen Bericht zusammengefasst. Eine Präsentation der Ergebnisse vor unserer Abteilung fand auch bereits statt.

Das Programmieren im Paar wende ich selbst schon seit einigen Jahren in meinen Vorlesungen an und muss sagen, dass die Ergebnisse bei den Studierenden durchweg positiv sind. Die vermittelten Inhalte bleiben viel besser hängen und die Teilnehmer schaffen auch schwierigere Aufgaben gemeinsam häufiger. Auch bei meiner eigenen Arbeit habe ich schon oft im Paar programmiert und bislang waren die Ergebnisse den (vielleicht nur gefühlten?) Mehraufwand immer wert. Die Qualität der Software war deutlich höher als bei einer Einzelleistung.

Schau dir doch einfach einmal Jonas‘ Artikel an und hinterlasse ihm gerne einen Kommentar! Er freut sich über jede Rückmeldung. Und ich denke, man darf junge Nachwuchsblogger auch ruhig mal ein wenig anfeuern! 🙂

Falls du selbst auch einen (Azubi-)Blog betreibst, dann melde dich einfach bei mir. Ich empfehle dich gerne weiter!

Programmierst du eher alleine oder auch im Team? Gibt es in eurem Unternehmen die Möglichkeit gemeinsam mit Partnern zu entwickeln?

Impedence Mismatch, OOP, Funktionale Programmierung

Impedence Mismatch, Objektorientierung und funktionale Programmierung

Veröffentlicht am 09.12.2016

Ich habe hier schon einige Artikel von Vladimir Khorikov verlinkt und es werden ständig mehr. Er schreibt aber auch wirklich gute Sachen! 🙂 Dieses Mal geht es um den Object-relational impedance mismatch (Link: https://de.wikipedia.org/wiki/Object-relational_impedance_mismatch) zwischen objektorientierter Programmierung und relationalen Datenbanken: OOP, FP, and object-relational impedance mismatch (Link: http://enterprisecraftsmanship.com/2016/11/03/oop-fp-and-object-relational-impedance-mismatch/).

Auch wenn sich das Thema vielleicht zunächst etwas hochtrabend anhört, erklärt Vladimir zu Beginn des Artikels erst einmal das Grundproblem: Objektorientierung und relationale Datenbanken passen einfach nicht gut zusammen. Objektreferenzen lassen sich nicht gut mit Fremdschlüsselbeziehungen abbilden und umgekehrt. Er verlinkt dazu selbst auch den – übrigens sehr empfehlenswerten – Artikel The Vietnam of Computer Science · Ted Neward’s Blog (Link: http://blogs.tedneward.com/post/the-vietnam-of-computer-science/) von Ted Neward. Darin werden Objektrelationale Abbildung – Wikipedia (Link: https://de.wikipedia.org/wiki/Objektrelationale_Abbildung)-Frameworks und -Tools freundlich ausgedrückt als nicht gerade die beste Erfindung der Informatik beschrieben.

Der Artikel erklärt aber auch alle zentralen Probleme mit einem Mapping zwischen den beiden Welten anschaulich und gut verständlich. Und alles wird mit einfach zu verstehenden Code-Beispielen illustriert.

  • Die bereits genannten Probleme beim Abbilden von Objektbeziehungen auf Fremdschlüsselbeziehungen.
  • Die fehlende Möglichkeit, Anwendungsentwickler-Podcast #8: Häufige Fragen im Fachgespräch – Vererbung (Link: /anwendungsentwickler-podcast-8-haeufige-fragen-im-fachgespraech-vererbung) in relationalen Datenbanken abzubilden.
  • Der ggfs. notwendige Aufbruch der Anwendungsentwickler-Podcast #6: Häufige Fragen im Fachgespräch – Kapselung (Link: /anwendungsentwickler-podcast-6-haeufige-fragen-im-fachgespraech-kapselung) von Objekten bei der Abbildung auf Tabellen.

Der interessante Teil kommt allerdings noch danach: Vladimir zeigt, dass die funktionale Programmierung viel besser zur relationalen Datenbankwelt passt und die OOP sinnvoller mit dokumentenorientierten Datenbanken zusammenarbeitet. Beispiele von SQL- verglichen mit F#-Code runden diese Empfehlung ab.

Ich empfehle allen (angehenden) Anwendungsentwicklern die Lektüre dieses umfangreichen Artikels, der eines der Grundprobleme moderner „Enterprise“-Entwicklung verdeutlicht.

Welche Erfahrungen hast du mit ORMs gemacht? Stand dir der Impedence Mismatch auch schon einmal im Weg? Oder konntest du bislang alle deine Anfoderungen umsetzen?

Tipps zum Programmieren lehren

Veröffentlicht am 29.06.2018

Der Podcast „Hanselminutes“ von Scott Hanselman darf in keiner Softwareentwickler-Playlist fehlen! In einer aktuellen Episode spricht er mit Dr. Neil Brown über Tipps für Lehrende, die ihren Schülern/Studenten das Programmieren beibringen wollen: Hanselminutes Technology Podcast – Fresh Air and Fresh Perspectives for Developers – Tips for Teaching Programming with Dr. Neil Brown (Link: https://hanselminutes.com/636/tips-for-teaching-programming-with-dr-neil-brown).

Da ich selbst in genau dieser Situation bin (in der Ausbildung bei der ALTE OLDENBURGER in Vechta (Link: https://aosbildung.de) aber auch in der PHWT Vechta (Link: https://www.phwt.de)), konnte ich einige Hinweise mitnehmen. Den Artikel, auf dem die Episode basiert, kannst du dir hier anschauen: Ten quick tips for teaching programming (Link: http://journals.plos.org/ploscompbiol/article?id=10.1371/journal.pcbi.1006023).

Einige Ideen aus dem Artikel habe ich bereits seit langer Zeit umgesetzt:

  • Pair Programming anstatt alleine Aufgaben zu lösen
  • Live-Coding anstatt Folienvorträge
  • Lernende nach den erwarteten Ergebnissen von Code fragen
  • Fokus auf eine einzelne Programmiersprache

Hast du noch weitere Tipps, wie man „Neulingen“ die Softwareentwicklung verständlich beibringen kann? Ich freue mich über Feedback und Anregungen!

DevOps – auf dem Mainframe!?

Veröffentlicht am 08.06.2018

DevOps ist ein Thema, das inzwischen schon nicht mehr als Hype bewertet werden kann. Stattdessen scheint es in den meisten Unternehmen inzwischen üblich zu sein, den Betrieb und die Entwicklung von Anwendungen zusammenzulegen bzw. zusammen zu organisieren. Dass diese moderne Möglichkeit inzwischen sogar auch auf (ur)alten Systemen möglich ist, zeigt dieser Artikel der Software AG: DevOps for the Mainframe – TECHniques – Communities (Link: http://techcommunity.softwareag.com/web/guest/techniques-blog/-/blogs/devops-for-the-mainframe).

Auch für den „guten alten“ Mainframe, der bislang häufig das Symbol für Legacy-Applikationen war, ist es inzwischen möglich, mit modernen Entwicklungsumgebungen und Deployment-Prozessen agil Software zu entwickeln. Man kann die 40 Jahre alte Datenbank Adabas inzwischen sogar in Docker-Containern laufen lassen. Wenn das mal nicht cool ist!

Auch ich selbst habe zu diesem Thema vor Kurzem einen Fachartikel für die ObjektSpektrum geschrieben. Dort habe ich erklärt, wie wir bei der ALTE OLDENBURGER unsere 20 Jahre alte Applikation auf den neusten Entwicklungsstand gebracht haben.

Und mein ehemaliger Azubi Jonas hat einen kleinen Artikel zum Besuch der Natural-Schulung für unseren Azubi-Blog geschrieben. Dort erfährst du, wie heutzutage Schulungen einer scheinbar veralteten Programmiersprache ablaufen. Schau gerne mal bei unserer „AOsbildung“ vorbei: Besuch der fortgeschrittenen Natural-Schulung – AOsbildung (Link: https://aosbildung.de/besuch-der-natural-schulung/).

Arbeitest du auf der Arbeit nur mit den neusten State-of-the-Art-Tools oder bist du in einer Legacy-Anwendung unterwegs? Versucht ihr, moderne Ideen bei der Entwicklung umzusetzen? Oder arbeitet ihr noch genauso wie vor 20 Jahren?

Hilfen zur Umsetzung der Datenschutzgrundverordnung

Veröffentlicht am 18.05.2018

Lange ist es nicht mehr hin, bis die neue Datenschutzgrundverordnung in Kraft tritt. Auch auf dieser Website musste ich dafür einige Anpassungen vornehmen. So habe ich z.B. alle Social-Plugins entfernt, Amazon-Produkte nur noch verlinkt und nicht mehr eingebettet, Facebook-Pixel usw. entfernt und natürlich die Datenschutzerklärung überarbeitet. Da das alles ganz schön viel Arbeit macht und mir einige Websites dabei geholfen haben, verlinke ich sie hier einfach mal:

  • DS-GVO gerechte Website – Schritt 1: Die Analyse personenbezogener Daten – Selbstständig im Netz (Link: https://www.selbstaendig-im-netz.de/recht/ds-gvo-gerechte-website-schritt-1-die-analyse-personenbezogener-daten/): Peer Wandiger zeigt am Beispiel seiner eigenen Website, was er tun musste, um sie DSGVO-konform zu machen.
  • DSGVO & WordPress: Technische Maßnahmen, die du umsetzen solltest (Link: https://raidboxes.de/dsgvo-wordpress-technische-massnahmen/): Eine gut verständliche und leicht abzuarbeitende Liste mit Maßnahmen für eine Website, die mit WordPress betrieben wird.
  • Kleinunternehmen und Vereine (Link: https://www.lda.bayern.de/de/kleine-unternehmen.html): „Offizielle“ Hilfe für die Umsetzung der DSGVO vom Bayerischen Landesamt für Datenschutzaufsicht.
  • DSGVO Datenschutz-Muster Generator für Webseiten, Shops, Blogs und Social Media – Datenschutz-Generator.de (Link: https://datenschutz-generator.de/): Ein Generator für die eigene Datenschutzerklärung von Rechtsanwalt Dr. Thomas Schwenke.
  • DSGVO: Datenschutzerklärung FAQ – Rechtsbelehrung Folge 55 (Jura-Podcast) – Rechtsbelehrung (Link: https://rechtsbelehrung.com/dsgvo-datenschutzerklaerung-faq-rechtsbelehrung-folge-55/): Häufige Fragen zur DSGVO in einer 1,5-stündigen Podcast-Episode beantwortet.

Habt ihr im Unternehmen auch viel Arbeit mit der Umsetzung der DSGVO? Oder betreibst du selbst eine Website, die du DSGVO-konform machen musst?

Veröffentlicht am 15.06.2018

Meine Azubis und ich haben an der Azubi-Recruiting-Studie 2018 des U-Form-Verlags teilgenommen und nun liegen die Ergebnisse vor: Studie Azubi-Recruiting Trends 2018 | u-form Testsysteme (Link: https://www.testsysteme.de/studie). Da wir bei der ALTE OLDENBURGER Krankenversicherung AG (Link: https://www.alte-oldenburger.de/) zum 01.08.2019 wieder mehrere Auszubildende (Fachinformatiker Anwendungsentwicklung und Systemintegration und Kaufleute für Versicherungen und Finanzen) in Vechta suchen, interessiert uns natürlich sehr, wie wir die Zielgruppe bestmöglich ansprechen können. Die Ergebnisse finde ich teilweise doch sehr überraschend, aber mit den meisten Aussagen hatte ich schon gerechnet.

  • Die Eltern der potentiellen Auszubildenden sind eine wichtige und insb. glaubwürdige Informationsquelle für die Schüler. Aber sie werden von den Ausbildern kaum berücksichtigt.
  • Die Hälfte der Schüler findet den Einsatz von WhatsApp im Bewerbungsprozess nicht gut, da sie Privates und die Bewerbung trennen möchten.
  • Auch Social Media wird eher kritisch gesehen. Fast 2/3 der Schüler lehnt den Einsatz von Snapchat bei der Bewerbung komplett ab.
  • Die Stellenanzeigen der Ausbildungsunternehmen sollten auch dringend überarbeitet werden. Statt die Qualifikationen der Bewerber aufzulisten, sollte auf die Perspektiven nach der Ausbildung eingegangen werden, um den Schülern den Beruf und das Unternehmen schmackhaft zu machen.
  • Und die „guten alten“ Standardfragen im Vorstellungsgespräch – Stärken/Schwächen, Perspektive in 5 Jahren, Grund für Bewerbung – hängen den Schülern inzwischen auch zum Hals raus.

Die Zusammenfassung der Studienergebnisse ist leider nicht kostenlos zu haben, aber eine Infografik mit den wichtigsten Ergebnissen gibt es hier: Azubi-Recruiting Trends 2018 (Link: https://www.testsysteme.de/wp-content/uploads/2018/06/Azubi-Recruiting-Trends-2018-Infografik.pdf).

Der Beruf des Fachinformatikers gehört übrigens zu den TOP-Berufen, also denen, die einen besonders guten Ruf bei den jungen Menschen genießen! 🙂

Podcast-Episode über IPv6

Veröffentlicht am 01.06.2018

Ab 2019 werde ich bei der Ausbildung bei der ALTE OLDENBURGER (Link: https://aosbildung.de/) auch eine/n Auszubildende/n zum Fachinformatiker Systemintegration betreuen. Dazu passend habe ich diese Woche einen interessanten Link für dich. Der Podcast „Request for Comments“ behandelt viele interessante Themen aus der IT und insb. der Netzwerktechnik. In der aktuellen Folge geht es über vier Stunden lang um das Thema IPv6: RFCE014: IPv6 | Request for Comments (Link: https://requestforcomments.de/archives/412).

Da ich mich ja nun auch bald intensiver mit diesem Thema beschäftigen muss, habe ich mir die Episode bereits komplett angehört. Und ich kann sie auf jeden Fall allen Fachinformatikern da draußen weiterempfehlen, egal ob Anwendungsentwicklung oder Systemintegration. IPv6 ist ein wichtiges Prüfungsthema für alle IT-Berufe.

In der Podcast-Episode wird das Thema sehr ausführlich und – wie ich finde – gut verständlich erklärt. Insbesondere auch die Praxisrelevanz wird beleuchtet. Man merkt, dass Clemens, der Interviewpartner, sich täglich mit der Thematik auseinandersetzt und nicht nur theoretisches Wissen vorträgt.

Setzt dein Unternehmen schon IPv6 ein oder lauft ihr noch auf IPv4? Bist du fit für IPv6 oder musst du noch Einiges lernen?

Code Smells – erste Anzeichen für ein nötiges Refactoring

Veröffentlicht am 11.05.2018

Im Blog von JetBrains hat Trisha Gee schon eine ganze Artikelserie zum Thema „Code Smells“ veröffentlicht, die mit diesem Beitrag beginnt: Code Smells: Null (Link: https://blog.jetbrains.com/idea/2017/08/code-smells-null/). „Riechender Code“ (oder besser stinkender Code) deutet darauf hin, dass ein Refactoring angesagt ist. Der Begriff wurde durch Code Smells (Link: https://martinfowler.com/bliki/CodeSmell.html) im Buch Martin Fowler – Refactoring: Improving the Design of Existing Code (Affiliate)* von Martin Fowler (das meiner Meinung nach jeder Softwareentwickler gelesen haben sollte) eingeführt. Immer wenn seine Oma bei Babys etwas roch, war es Zeit, die Windeln zu wechseln. Und das übertrug er dann auf Code: Immer wenn Code seltsam aussieht (riechen kann man ihn ja schlecht), sollte man darüber nachdenken, wie man ihn optimieren könnte.

Martin Fowler - Refactoring: Improving the Design of Existing Code (Affiliate)*

Die „klassischen“ Code Smells sind z.B. doppelter Code oder lange Methoden. Trisha Gee behandelt in ihrer Artikelreihe allerdings Dinge, die für viele Entwickler alltäglich sein dürften: null, if-Statements, Iterationen. Sie zeigt an umfangreichen Beispielen, warum der Code optimiert werden könnte und auch wie man dies tun kann. Dabei wird ab und an etwas Werbung für die Java-IDE IntelliJ eingestreut, die viele Refactorings automatisiert durchführen kann, aber auch für Entwickler, die nicht die JetBrains-IDE nutzen, sind viele wertvolle Ideen dabei.

Welche Code Smells begegnen dir in der Praxis häufig? Und welche hinterlässt du vielleicht sogar für deine Kollegen? 😉

Eigene Zeichnungen in Präsentationen

Veröffentlicht am 04.05.2018

Nach der schriftlichen Sommerprüfung in der letzten Woche geht es nun bei vielen Prüflingen los mit der Vorbereitung auf das Fachgespräch und die Projektpräsentation. Wie du weißt, vertrete ich einen eher visuellen Präsentationsstil. Dazu passend habe ich hier zwei Artikel, die Tipps zur konkreten Gestaltung von PowerPoint-Präsentationen geben bzw. mal einen völlig anderen Ansatz zeigen: das Zeichnen von Comics.

  • Präsentation mit Powerpoint? Mit diesen Tipps wird sie trotzdem schick | ❤ t3n (Link: https://t3n.de/news/schoene-praesentation-powerpoint-967492/)
  • How to teach technical concepts with cartoons – Julia Evans (Link: https://jvns.ca/teach-tech-with-cartoons/)

Zugegeben: Letzterer Ansatz ist vielleicht etwas sehr extrem. Und ich habe bislang auch noch keine „gezeichnete“ Abschlusspräsentation gesehen. Aber ich möchte mit dieser Website auch dazu anregen, einmal aus den gedanklichen Grenzen auszubrechen. Du musst ja nicht gleich deine ganze Präsentation zeichnen, aber vielleicht bietet sich ja eine kleine eigene Darstellung für einen Teil deiner Projektpräsentation an. Anstatt ein langweiliges PowerPoint-Diagramm zu erstellen, könntest du ja vielleicht versuchen, eine selbst gezeichnete Darstellung einzubauen. Schau z.B. mal in meine Präsentation zum Thema Property-based Testing mit JUnit-Quickcheck (Link: https://www.slideshare.net/StefanMacke/propertybased-testing-mit-junitquickcheck-81040667) für Inspiration!

Primfaktorenzerlegung mit der Hand gezeichnet

Die Zeichnungen habe ich mit Hilfe des Buches Die Sketchnote Starthilfe: Über 200 Strich-für-Strich-Anleitungen und Schriften zum Nachzeichnen (Affiliate)* erstellt.

Die Sketchnote Starthilfe: Über 200 Strich-für-Strich-Anleitungen und Schriften zum Nachzeichnen (Affiliate)*

Genau wie ich empfehle, die Fotos für die Präsentation komplett selbst aufzunehmen, könnte eine eigene Zeichnung deiner Präsentation eine ganz individuelle Note versehen, die kein anderer Prüfling haben wird. Damit könntest du dich also durchaus positiv von der Konkurrenz abheben!

Wie versuchst du, dich bei deiner Projektpräsentation von den anderen Prüflingen abzuheben? Welche individuellen Elemente baust du in deine Präsentation ein?

Kommentare

  • Von Markus Wessjohann am 04.05.2018
    Moin Stefan, man sollte sich aber die Wirkung von Zeichnungen auf die Zuhörer im klaren sein. Hierzu gibt es ein kurzes Statment in folgender Präsentation What Is the Purpose of the LLKD Community? (Link: https://www.infoq.com/presentations/agile-salesmen). Ungefähr in der Mitte der Präsentation. Aber ich bin ganz deiner Meinung, dass man mit gezeichneten Figuren sich absetzen kann, gegebnüber den Standard Folien (Bild + Schlagwort). Gruß Markus PS: die Präsentation ist auch ohne das kurze Statment zu gezeichnetet Folien sehr intressant.

  • Von Stefan Macke am 04.05.2018
    Hallo Markus,

    danke für den Link. Das nehme ich mal auf die ToWatch-Liste! 🙂

    Viele Grüße! Stefan

Hilfe beim Design von RESTful APIs

Veröffentlicht am 13.04.2018

Representational State Transfer (REST) ist heutzutage in aller Munde. Jeder Softwareentwickler, der etwas auf sich hält, gestaltet seine Anwendungen heute so, dass sie über eine RESTful API erreichbar sind. Aber in der Praxis ist die Modellierung einer verständlichen und nachvollziehbaren Schnittstelle alles andere als trivial. Auch wenn die wenigen verfügbaren HTTP-Methoden (GET, POST usw.) doch eigentlich alle CRUD-Operationen abbilden, steht man doch häufig vor der Frage, welche man nun für die zu implementierende Operation verwenden sollte. Und außerdem gibt es ja noch so Dinge wie die Idempotenz, die es einzuhalten gilt. Gerade für Einsteiger ist die sinnvolle Definition einer Schnittstelle äußerst schwierig. In diesen beiden Artikeln gibt es sehr ausführliche Einführungen in die Gestaltung von REST-APIs:

  • RESTful APIs richtig gemacht – Anleitung für bessere REST-Schnittstellen (Link: https://jax.de/blog/software-architecture-design/restful-apis-richtig-gemacht/)
  • Pragmatisch, praktisch, gut: Einführung ins RESTful-API-Design (Link: https://entwickler.de/online/web/restful-api-design-intro-579826380.html)

Hast du auch schon REST-Schnittstellen definiert? Was sind deine größten Probleme bei der Arbeit mit REST?

Java – quo vadis?

Veröffentlicht am 30.03.2018

Falls du mit Java entwickelst, hast du es bestimmt mitbekommen: Java 10 ist verfügbar! Hier gibt es eine gute Übersicht der Neuerungen in der Sprache: Java 10, Neues im JDK 10, Java 9-Nachfolger OpenJDK 10, Java 18.3, Java SE 10 (Link: http://www.tutego.de/java/java-10-oracle-jdk-10-openjdk.html).

Und falls du es nicht abwarten kannst, gibt es hier schon einen Vorgeschmack auf Java 11: An Early Look at Features Targeted for Java 11 | Java Code Geeks – 2018 (Link: https://www.javacodegeeks.com/2018/02/early-look-features-targeted-java-11.html).

Es wird sicherlich noch ein wenig dauern, bis wir im Unternehmen die neue Java-Version einsetzen können. Aktuell arbeiten wir noch auf Java 8. Das heißt, wir müssen zunächst einmal den Umstieg auf Java 9 und das damit eingeführte Modulsystem hinbekommen. Hier gibt es ein schönes Tutorial für die neuen Features in Java 9: Code First Java 9 Tutorial – blog@CodeFX (Link: http://blog.codefx.org/java/java-9-tutorial/).

Ach übrigens: Java ist und bleibt eine der Top-Programmiersprachen! Top 10 der Programmiersprachen: Die aktuellen Rankings im Vergleich – entwickler.de (Link: https://entwickler.de/online/development/top-10-programmiersprachen-579834326.html).

Welche Version setzt du in der Praxis ein? Welche neuen Features gefallen dir besonders gut?

TDD FTW!

Veröffentlicht am 23.03.2018

100% Code Coverage – TDD mit Java EE (Link: https://www.slideshare.net/StefanMacke/100-code-coverage-tdd-mit-java-ee) letzte Woche hatte auch „TDD“ (Test Driven Development) im Titel. Und wenn du mir schon länger folgst, weißt du, dass ich automatisierte Tests liebe! 🙂 Daher gibt es heute einige spannende Links rund um TDD.

  • To TDD or not to TDD – Enterprise Craftsmanship (Link: http://enterprisecraftsmanship.com/2018/01/16/tdd-not-tdd/)
    Dieser Artikel diskutiert, ob und wann der Einsatz von TDD sinnvoll ist. Die Kernaussage passt zu meiner Einstellung: immer! Außer beim explorativen Programmieren, wenn man noch gar nicht weiß, ob das gestellte Problem überhaupt wie gedacht lösbar ist.
  • TDD & Professionalism – Software People Inspiring (Link: http://codemanship.co.uk/parlezuml/blog/?postid=1524)
    Eine schöne Diskussion darüber, warum man als professioneller Softwareentwickler gar nicht an TDD vorbeikommen kann! Die Argumentation finde ich sehr gelungen!
  • 10 Classic TDD Mistakes – Software People Inspiring (Link: http://codemanship.co.uk/parlezuml/blog/?postid=1533)
    Und zum Schluss noch eine Liste mit häufigen Fehlern beim Einsatz von TDD und warum man sie vermeiden sollte.

Setzt du bei deiner täglichen Arbeit TDD ein? Warum (nicht)?

Best Practices für Unit-Tests

Veröffentlicht am 16.03.2018

Passend zu meinem 100 % Code Coverage – TDD mit Java EE (Link: https://programm.javaland.eu/2018/#/scheduledEvent/548938) habe ich als Link der Woche eine schöne Liste mit Empfehlungen für Unit-Tests. Es geht zwar um Java und JUnit, aber die Ideen sind meiner Meinung nach völlig unabhängig von der verwendeten Programmiersprache: Top 20 JUnit Testcase Best Practices (Link: https://howtodoinjava.com/best-practices/unit-testing-best-practices-junit-reference-guide/).

Die wichtigsten Tipps sind:

  • Alle Tests müssen isoliert voneinander laufen.
  • Externe Komponenten (Abhängigkeiten) müssen durch Stubs oder Mocks ersetzt werden.
  • Sprechende Namen und insb. sprechende Fehlermeldungen bei fehlschlagenden Tests sind absolut notwendig.
  • Teste nicht nur den „Happy Path“, sondern insb. auch die Fehlersituationen.
  • Automatisiere die Ausführung der Tests (z.B. im Buildscript).

Hast du noch weitere „Regeln“ oder Tipps für gute Unit-Tests? Ich freue mich über deinen Kommentar!

IDE Wars!

Veröffentlicht am 09.03.2018

Über bestimmte Themen können sich Softwareentwickler vorzüglich streiten: Tabs vs. Spaces, Use whatever brace style you prefer. But not this. Don’t do this. Seek help instead of this. (Link: https://twitter.com/udellgames/status/788690145822306304) oder natürlich auch die „richtige“ Programmiersprache. Und selbstverständlich kann man auch bei den eingesetzten Tools geteilter Meinung sein – insb. bei der Entscheidung für einen Texteditor (wobei für mich der Editor War (Link: https://de.wikipedia.org/wiki/Editor_War) natürlich längst zugunsten des Vim beendet wurde ;-)). Aber auch die heißgeliebten IDEs sind oftmals Stein des Anstoßes zwischen Entwicklern. Und gerade im Java-Umfeld gibt es immer wieder Diskussionen bzgl. der „besten“ Entwicklungsumgebung. Hier kommt ein Artikel, der ausnahmsweise mal Eclipse gegenüber IntelliJ IDEA den Vorzug gibt: I Still Prefer Eclipse Over IntelliJ IDEA (Link: https://techblog.bozho.net/still-prefer-eclipse-intellij-idea/).

Ich muss sagen, dass ich Eclipse nun seit vielen Jahren benutze und tatsächlich keinen Grund sehe zu wechseln. Die Produktivitätstipps für Softwareentwickler – Anwendungsentwickler-Podcast #51 sind in Fleisch und Blut übergegangen und performant (genug) ist die Umgebung auch. Außerdem ist sie (meiner Meinung nach) der de-facto Standard für Entwicklungsumgebungen. Teilweise habe ich auf meiner Maschine vier verschiedene Eclipse-Installationen parallel laufen, weil z.B. die Entwicklungsumgebung für Natural und auch den Integration Server auf Eclipse basiert.

Welche IDE verwendest du am liebsten? Warum hast du dich so entschieden?

Kommentare

  • Von Thorsten Kreutz (Link: http://www.kreutz-edv-consulting.de) am 09.03.2018
    In einer Emacs Meeting Gruppe sind ein paar Stichworte gefallen, warum Emacs- und Vi- oder VIM auch in der Zeit von Starken IDEs noch Vorzüge haben können. Wenn wir die Situation eines Softwareentwicklers einmal mit einem Schied vergleichen. Das erste, was ein Schmied lernen musste, war wie er seine eigenen Werkzeuge herstellen kann. Im Prinzip ist es ja dass, was auch von einem Softwareentwickler erwartet werden kann – nämlich, dass er sich seine eigenen Werkzeuge auch herstellt, die er zum Arbeiten benötigt. Diese Anpassungsmöglichkeiten findet man in Vi oder Emacs. Der nächste Punkt ist „Effizienz“. – Put all Things in the Editor – Das ist das Credo von Vi- oder Emacs. Als Entwickler möchte ich nicht unnötig meine Hände von der Tastatur nehmen müssen. Rechnet man die Mausbewegungen- und Klicks – ist das der Punkt, der Effizienz ausbremsen kann. Vergleichen wir diesen Vorgang mit einer Restaurant-Küche. In einer Restaurant-Küche ist es völlig egal, ob es „schöne Geräte“ gibt – die Küche muss hunderte von Menüs ausbringen, wenn die Gäste Hunger haben. Gewissermaßen wird das auch von einem Softwareentwickler erwartet – Softwareentwickler lesen und schreiben letztendlich „Text“. Alles was dann stört- oder im Weg ist, den Workflow behindert – geht entgegen der Effizienz. Ein letzter Punkt – „Lebenszeit“ eines Editors. Eclipse, Emacs oder auch Vi / VIM können problemlos auf allen Arbeitsumgebungen eingerichtet werden – seit 20 Jahren – unverändert. Das heißt, man muss einmal richtig viel lernen, danach hat man dann erst einmal Ruhe. Man kann zu Hause auf dem Mac, im Büro mit Ubuntu und sonstwo mit Windows arbeiten – die Umgebung ist gleich. Das kann man nicht von allen kommerziellen Produkten behaupten. Ein kommerzielles Produkt „lebt“ solange, wie es das Unternehmen gibt. Unternehmen kommen und gehen. Org-Mode von Carsten Dominik – „Living in Plan Text“ – zeigt, wie man eine Arbeitsabläufe optimiert mit dem Emacs nach David Allens Getting Things Done Methode organisieren kann. Natürlich gibt es auch Gegenargumente. Im Zeitalter moderner „Browser“ mit allen möglichen Entwicklungswerkzeugen, kann der Emacs oder Vi nur noch bedingt mithalten. Auch PDF – geht nicht – zieht immer mehr in Workflows ein. Sicher sind gute IDEs auch eine Hilfestellung – vielleicht auch beim Lernen – aber der Beste „Debugger“ ist doch der „Kopf“ des Programmierers.
  • Von Pascal am 09.03.2018
    Früher habe ich Netbeans verwendet. Das war dann mit irgendeiner Version so langsam beim indexieren, dass ich auf PHPStorm umgestiegen bin. Das ist jetzt ca. 6 Jahre her und ich will auf nichts anderes wechseln. Für mich einfach die beste IDE im Webbereich.

  • Von Stefan Macke am 09.03.2018
    Hallo Thorsten,

    vielen Dank für den umfangreichen Kommentar. Da kann ich in allen Punkten nur zustimmen! Wobei ich versuche, die Anpassungen am Editor möglichst klein zu halten, da ich meine Konfiguration nicht auf allen Geräten zur Verfügung haben kann und dann ggfs. wieder „umlernen“ muss, wenn ich z.B. auf einem nackten Linux-System arbeite.

    Viele Grüße! Stefan

  • Von Stefan Macke am 09.03.2018
    Schön, dass du die für dich passende Umgebung gefunden hast. Das ist für deine Produktivität das Wichtigste.

REST-API-Dokumentation mit Swagger

Veröffentlicht am 02.03.2018

Für die heute dominierenden REST-APIs braucht man eine Möglichkeit, die technischen Schnittstellen so zu definieren, das anbietende und aufrufende Systeme sie schnell verstehen können. Als De-facto-Standard hat sich aktuell Swagger etabliert: Swagger: Mehr als nur Schnittstellenbeschreibung (Link: https://entwickler.de/online/web/openapi-swagger-579827368.html).

Damit dokumentiere ich in meinem aktuellen Projekt auch eine REST-Schnittstelle und die Mächtigkeit hat mich schon beeindruckt. Swagger kann z.B. ohne großen Aufwand eine komplette Weboberfläche mit der API-Dokumentation erstellen, über die sogar jeder Service direkt aus dem Browser heraus aufrufbar und damit testbar ist. Das sieht wirklich ziemlich cool aus und erzeugt beim Programmierer auch nur wenig Aufwand. In unserem Java-Projekt musste ich nur wenige Zeilen Code schreiben und der Rest passierte automatisch. Als plattformunabhängige Schnittstellenbeschreibung setze ich in Zukunft also auf Swagger.

Hast du auch schon einmal eine REST-Schnittstelle entwickelt? Wie hast du sie dokumentiert? Nutzt du auch Swagger oder kannst du noch andere Werkzeuge empfehlen?

Platform as a Service und Serverless Computing

Cloud-Computing: PaaS vs. Serverless

Veröffentlicht am 23.02.2018

Auf der VillageCon (Link: https://www.villagecon.io/) erzähle ich heute etwas über Moderne IT-Infrastrukturen (Stefan Macke) (Link: https://www.villagecon.io/speaker/stefan-macke/). Dabei gehe ich insbesondere die klassischen Modelle des Cloud Computings durch. Von Infrastructure-as-a-Service (IaaS), über Platform-as-a-Service (PaaS), bis hin zu Software-as-a-Service (SaaS) ist alles dabei. Allerdings gibt es aktuell ja noch eine weitere Möglichkeit: Function-as-a-Server (FaaS) oder auch „Serverlesss Computing“ genannt.

In Vorbereitung auf meinen Vortrag habe ich einige sehr gute Artikel rund um das Thema Cloud Computing und moderne Möglichkeiten des Hostings einer Anwendung gelesen. Die folgenden drei kann ich weiterempfehlen:

  • Amazon Elastic Beanstalk Tutorial – The ULTIMATE Guide | Java Code Geeks – 2018 (Link: https://www.javacodegeeks.com/2017/12/amazon-elastic-beanstalk-tutorial.html)
    Ein sehr umfangreiches Schritt-für-Schritt-Tutorial, um deine erste (Java-)Anwendung in die PaaS-Plattform von Amazon zu bringen.
  • Serverless FaaS with AWS Lambda and Java | The Couchbase Blog (Link: https://blog.couchbase.com/serverless-faas-aws-lambda-java/)
    Ein gutes Tutorial, um deine erste eigene Function bei Amazon-Lambda einzustellen. In der Einleitung werden auch noch einmal schön die unterschiedlichen Hosting-Modelle abgegrenzt.
  • Serverlos durch die Nacht: Wie gehen Funktionen ohne Server? (Link: https://jaxenter.de/serverless-best-practices-61856)
    Ein schöner Vergleich der aktuellen Möglichkeiten mit gut verständlichen Schaubildern zur Abgrenzung der Komponenten.

In den nächsten Wochen wird es übrigens auch eine Podcast-Reihe zum Thema Cloud Computing geben. Denn prüfungsrelevant ist das Zeug auch noch! 🙂

Wie hostest du bzw. dein Unternehmen deine Anwendungen? Setzt ihr schon voll auf Serverless oder habt ihr noch die eigene Hardware bei euch im Keller stehen?

Clean Code

Buchclub zu „Clean Code“

Veröffentlicht am 09.02.2018

Ich weiß nicht, wie oft ich im Blog oder im Podcast schon das Buch Robert C. Martin – Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)* von Robert C. Martin empfohlen habe. Es hat mir bei meiner Ausbildung zum Softwareentwickler sehr geholfen. Daher möchte ich jetzt mit meinen aktuellen Azubis einen Buchclub starten, der Clean Code bearbeitet. Die Azubis werden jeden Monat zu einem Thema des Buchs eine Präsentation vor unserer Abteilung halten. Dadurch bin auch ich gezwungen, das Buch noch einmal von vorne bis hinten zu lesen. 🙂

In irgendeiner Form werde ich die Ergebnisse auch im Blog oder Podcast zur Verfügung stellen. Wenn du also beim Buchclub mitmachen willst, nichts wie los und schaff dir das Buch an! Eine Investition, die sich sofort auszahlen wird. So viele praktische Tipps zur Programmierung – komplett unabhängig von der Programmiersprache – wirst du in wenigen anderen Büchern finden.

Und als kurzen Lesetipp zum Thema Clean Code kann ich dir noch diesen Artikel von Jason Gorman empfehlen: Clean Code isn’t a Programming Luxury. It’s a Business Necessity (Link: http://codemanship.co.uk/parlezuml/blog/?postid=1487). Darin zeigt er noch einmal die Wichtigkeit von Clean Code für die Praxis. Es handelt sich hierbei nicht um ein „Nice to Have“ oder Luxus-Feature, sondern um eine absolute Notwendigkeit.

Robert C. Martin - Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*

Hast du das Buch schon gelesen? Welche Inhalte haben dir am besten gefallen?

Azubimarketing

Veröffentlicht am 26.01.2018

Meine Azubis und ich planen aktuell einige Erweiterungen im Bereich des Azubimarketings für unser Unternehmen. Dafür sollen sich die Azubis selbst etwas einfallen lassen, um die (Urkunde für hervorragende Leistung in der Ausbildung der ALTE OLDENBURGER (Link: https://www.instagram.com/p/BY3PZvbH_k1/?taken-by=stefan.macke)) Ausbildung bei der ALTE OLDENBURGER (Link: https://www.alte-oldenburger.de/karriere/ausbildung.html) potentiellen Azubis schmackhaft zu machen. Einige Anregungen dafür hole ich persönlich mir gerne bei wirAUSBILDER (Link: https://www.wirausbilder.de). Zwei Artikel sind mir dabei in letzter Zeit im Gedächtnis geblieben:

  • Ausbilder im Azubimarketing nicht vergessen (Link: https://www.wirausbilder.de/2017/08/ausbilder-im-azubimarketing-nicht-vergessen/)
  • Zielgruppe Eltern im Azubimarketing (Link: https://www.wirausbilder.de/2017/09/zielgruppe-eltern-im-azubimarketing/)

Die Ausbilder in unserem Unternehmen (von denen ich einer bin), stellen wir auf der Website bereits vor (z.B. hier ganz unten: Informatik-Ausbildung bei der ALTE OLDENBURGER (Link: https://www.alte-oldenburger.de/karriere/ausbildung/informatik.html)). Und laut Rückmeldung unserer aktuellen Bewerber kommt das auch gut bei der Zielgruppe an. Außerdem erwähne ich natürlich auf meiner Website und bei unserem Stammtisch – SEROM (Link: https://serom.de/stammtisch/) immer wieder meinen Arbeitgeber, sodass das Unternehmen hoffentlich auch darüber etwas bekannter für die Ausbildung im IT-Bereich in unserer Region wird.

Die Idee des zweiten Artikels haben wir wahrscheinlich etwas unfreiwillig umgesetzt, indem wir mit einer „altmodischen“ Stellenanzeige der ALTE OLDENBURGER (Link: https://www.instagram.com/p/BZGqazonuMx/?taken-by=stefan.macke) Bewerber für die Ausbildung 2018 gesucht haben. Ich vermute (und Rückfragen bei den eingeladenen Bewerbern bestätigen mir das), dass Zeitungen nur noch von den Eltern der potentiellen Azubis gelesen werden. Die meisten Bewerber haben uns eher über ausbildung.de (Link: http://ausbildung.de) und andere Portale gefunden.

Wie hast du nach deiner Ausbildungsstelle gesucht? In welchen Medien sollten Unternehmen deiner Meinung nach heutzutage nach Bewerbern suchen?

Frohe Weihnachten!

Frohe Weihnachten!

Veröffentlicht am 22.12.2017

Weihnachten steht vor der Tür und dies hier wird mein letzter Beitrag für 2017 sein. Passend zum Fest habe ich einen kurzen Artikel als Leseempfehlung: Why Experiences Are Better Than Things (Link: https://www.becomingminimalist.com/experiences/). Darin beschreibt Joshua Becker, warum (gemeinsame) Erfahrungen besser sind als materielle Geschenke. Man gewinnt z.B. mehr Freude und bewahrt sich langfristige Erinnerungen. Außerdem müllt man sein Leben nicht mit unnützem Kram zu. Und gerade in der IT ist die Halbwertszeit von technischen Gegenständen ja ohnehin sehr kurz. Wer freut sich nach einem halben Jahr noch über das „neuste“ Handy, das es zu Weihnachten gab?

Wie kann man diese Einsicht nun auf unseren Programmieralltag übertragen? Verschenke doch mal eine Pair-Programming-Stunde an die Kollegen! Oder lade jemanden zum gemeinsamen Code-Review ein. Dabei lernt ihr beide sicherlich etwas dazu. Oder ihr feiert das Release eurer neusten Software gemeinsam in einem netten Restaurant. Oder ihr nehmt gemeinsam an einer User-Group oder Konferenz teil (Organisation einer eigenen User Group – Anwendungsentwickler-Podcast #81)!

Ich wünsche allen Lesern und Hörern da draußen frohe Festtage und einen guten Start ins neue Jahr 2018! Und allen Azubis, die direkt im Januar zur mündlichen Prüfung müssen, drücke ich die Daumen und wünsche viel Erfolg!

Verschenkst du technische Gadgets zu Weihnachten? Oder legst du den Fokus auf gemeinsame Erlebnisse? An welche Events aus deinem Unternehmen denkst du gerne zurück?

Kritik an LaTeX

Veröffentlicht am 15.12.2017

Kaum zu glauben: Es gibt Menschen, die LaTeX nicht für das beste Textsatzsystem der Welt halten! 🙂 In diesem Artikel beschreibt Peter Hoffmann, welche Vor- und Nachteile LaTeX hat und warum er inzwischen der Meinung ist, dass LaTeX nicht (mehr) das beste Textverarbeitungssystem ist: Let’s find something better than LaTeX (Link: https://dev.to/hoffmann/lets-find-something-better-then-latex).

Ich kann seine Begründung durchaus nachvollziehen. Ich sehe regelmäßig, wie schwer sich Neulinge mit der Einarbeitung in LaTeX tun, und welche Fehler die Dokumente am Ende enthalten, die mit einem ihnen bekannten System sehr wahrscheinlich nicht aufgetreten wären. Dennoch bin ich immer noch ein Verfechter der Vorteile (die auch im Artikel genannt werden). Insb. die Plain-Text-Dateien finde ich äußerst wichtig, weil sie hervorragend versioniert werden können (z.B. Einführung in die Versionsverwaltung mit Git (Teil 1) – Anwendungsentwickler-Podcast #76 (Link: /einfuehrung-in-die-versionsverwaltung-mit-git-teil-1-anwendungsentwickler-podcast-76)). Und auch die Automatisierungsmöglichkeiten habe ich selbst schon für meine eigenen Dokumente genutzt. Ein kleines Batch-File geschrieben und schon kann man massenweise hervorragend gesetzte Briefe verschicken.

Gerade für Entwickler sollte die „Programmierung“ der Dokumente auch nicht fremd sein. Aber ich kann trotzdem verstehen, wenn man den zusätzlichen Lernaufwand scheut. Falls du es einmal probieren willst, schau dir doch meine YouTube-Videos an: Einführung in LaTeX: 00. Einleitung. Und wenn dir das alles zu viel ist, kannst du ja immer noch meine Microsoft Word-/LibreOffice-Vorlage für die Projektdokumentation der IT-Berufe (Link: http://dieperfekteprojektdokumentation.de) nutzen. 😉

Welches Textsatzsystem verwendest du? Tippst du einfach drauflos oder setzt du das System „professionell“ ein?

Vergleich von Unit-Test-Frameworks für Java

Veröffentlicht am 08.12.2017

Wenn du täglich Unit-Tests schreibst, solltest du vielleicht einmal darüber nachdenken, ob es Alternativen zu dem von dir verwendeten Framework gibt. Insbesondere im Java-Umfeld gibt es verschiedene Möglichkeiten für die Entwicklung von automatisierten Tests, z.B. JUnit 4 oder 5, TestNG oder Spock. Letzteres sieht für Java-Entwickler zunächst etwas seltsam aus, da die Tests in der Programmiersprache Groovy programmiert werden und nicht in Java. Dieser Artikel stellt „klassische“ Unit-Tests mit JUnit denen in Spock gegenüber und zeigt die Vor- und Nachteile beider Varianten, z.B. hinsichtlich der Lesbarkeit für den Entwickler: Spock testing framework versus JUnit (Link: http://blog.codepipes.com/testing/spock-vs-junit.html).

Die Diskussion verschiedener Frameworks ist schon eher etwas für fortgeschrittene Unit-Tester. In vielen Unternehmen scheitert das Thema bereits am fehlenden grundsätzlichen Einsatz von automatisierten Tests. Wenn du also bislang gar keine Tests geschrieben hast, ist es an der Zeit, das zu ändern. Und dann solltest du eher auf den „Standard“ JUnit setzen, da du hierzu sicherlich mehr Hilfe und Literatur findest. Aber die Hauptsache ist, dass du anfängst!

Welche Frameworks setzt du für automatisierte Tests in deinen Projekten ein? Hast du ein Lieblingsframework?

Containerisierung mit Docker

Veröffentlicht am 27.11.2017

Containerisierung ist in aller Munde. Und Docker etabliert sich dabei als De-Facto-Standard. Wer als Anwendungsentwickler heute noch nichts von Docker gehört hat, ist definitiv nicht auf dem Laufenden. Unabhängig davon, ob die Technologie im eigenen Unternehmen eingesetzt wird, sollte man sich mit der grundsätzlichen Idee von Containern beschäftigen. Hier gibt es eine schöne Einführung (nicht nur für Java-Entwickler): Docker for Java Developers – The Big Picture (Link: http://blog.codepipes.com/containers/docker-for-java-big-picture.html).

Falls du mit Java entwickelst, bieten dir viele Frameworks bereits eine gute Unterstützung für die Arbeit mit Docker an, z.B. Arquillian: Testing in Arquillian with Docker Containers (Link: http://www.softwaretestingmagazine.com/knowledge/testing-in-arquillian-with-docker-containers/). Und für viele andere Plattformen sieht es ähnlich aus. Sogar die Software AG entwickelt aktuell eine Docker-Unterstützung in ihren jahrzehntealten Technologien Adabas und Natural: Software AG’s support for Docker (Link: https://techcommunity.softwareag.com/techniques-blog/-/blogs/software-ag-s-support-for-docker).

Setzt du schon Docker (oder eine andere Container-Technologie) ein? Wofür nutzt du die Container?

Arbeit mit der Linux-Shell

Veröffentlicht am 24.11.2017

Der eigene Webserver (Teil 1) – Anwendungsentwickler-Podcast #88, setzen meine Azubis direkt zu Beginn ihrer Ausbildung Webhosting, Webspace und Homepagelösungen von 1blu – vServer (Affiliate)* auf. Damit die Kosten dafür nicht explodieren, verwenden wir Linux als Betriebssystem. Dabei kann ich dann ganz nebenbei auch einen – meiner Meinung nach – wichtigen Ausbildungsinhalt unterbringen: Die Arbeit mit der Kommandozeile.

Linux lässt sich hervorragend ausschließlich über die Kommandozeile bedienen und ich denke, dass jeder Informatiker seinen Computer so steuern können sollte. Denn alles, was eingegeben werden kann, lässt sich scripten und damit auch automatisieren. Und nichts anderes machen wir Entwickler doch den ganzen Tag, wenn wir programmieren.

Hier sind zwei interessante Listen mit „Tricks“ für die Linux-Shell, die die Pipeline verwenden, um aus bestehenden Befehlen neue Funktionen zusammenzubauen. Die Software-Architektur dahinter heißt übrigens Pipes und Filter – Wikipedia (Link: https://de.wikipedia.org/wiki/Pipes_und_Filter). Das darf man für die IHK-Prüfung wissen! 😉

  • Most Useful Linux Command Line Tricks (Link: https://dzone.com/articles/most-useful-linux-command-line-tricks)
  • Bash One-Liners Explained, Part I: Working with files (Link: http://www.catonmat.net/blog/bash-one-liners-explained-part-one/)

Ein sehr gutes Buch zum Einstieg in Linux (aber auch für die Vertiefung) ist der „Kofler“: Der Kofler – Das Linux-Handbuch von Rheinwerk (Affiliate)*.

Der Kofler - Das Linux-Handbuch von Rheinwerk (Affiliate)*

Hast du noch weitere Tipps für die Kommandozeile? Oder kennst du vielleicht noch gute Einführungsartikel in die Arbeit mit der Shell? Dann freue ich mich auf deinen Kommentar!

Wie die Medien unser (Entwickler-)Weltbild beeinflussen

Veröffentlicht am 17.11.2017

Vor Kurzem bin ich über diesen äußerst interessanten Artikel gestolpert: This Is How Your Fear and Outrage Are Being Sold for Profit (Link: https://medium.com/the-mission/the-enemy-in-our-feeds-e86511488de). Tobias Rose-Stockwell erläutert darin anhand mehrerer Medienereignisse – z.B. Ebola in New York, Trumps Wahlkampf usw. – wie wir tagtäglich von den Medien beeinflusst werden. Scheinbar alltägliche lebensbedrohliche Ereignisse wie Terroranschläge entpuppen sich bei genauerer Analyse als äußerst unwahrscheinlich für den Einzelnen. Aber da man mit reißerischen Themen mehr Werbeeinnahmen erwirtschaften kann, werden sie halt bevorzugt. Und sogar so dominant verbreitet, dass sie kaum noch hinterfragt werden.

Ich habe den Eindruck, dass es in der Softwareentwicklung genauso läuft. Auf den großen Konferenzen werden fast nur „Hype-Themen“ besprochen, aber wichtige Grundlagen werden kaum behandelt. Ob Serverless, Blockchain, Vue.js oder andere hippe Entwicklungen, der Fokus liegt häufig auf Themen, die nur für einen Bruchteil der Unternehmen relevant sind. Es kann doch nicht jedes Unternehmen so arbeiten wie Netflix, Amazon und Co. Und das ist auch gar nicht schlimm! Aber wenn man als Entwickler in einem mittelständischen Unternehmen arbeitet und sich auf diesen Konferenzen umschaut, bekommt man schnell Angst, wann die eigene IT wohl nicht mehr mithalten kann.

Dabei sieht es im Großteil der Unternehmen da draußen meist noch viel schlimmer aus: keine Unit-Tests, kein Continuous Integration, kein Pair Programming. Die Basics moderner Softwareentwicklung sind für viele Unternehmen auch heute noch keine Selbstverständlichkeit. Das sehe ich regelmäßig bei den IHK-Prüfungen.

Vielleicht sollten wir als Entwickler – die ja schon ein „angeborenes“ Interesse an den neusten Technologien haben – auch ein wenig mehr hinterfragen und nicht jede neue Technologie von irgendeiner Konferenz als das neue Nonplusultra interpretieren. Ein gesundes Maß an Skepsis ist – genau wie beim Medienkonsum – angebracht.

Hast du schon einmal eine „unverzichtbare“ Technologie eingeführt und später festgestellt, dass sie doch gar nicht so toll ist? Welche Hype-Themen sind für dich aktuell völlig unsinnig?

Kommentare

  • Von Marcel am 17.11.2017
    Ich bin Hypalergiker, ein Kunstwort das ich soeben schuf. 🙂 Ich hab den 3D-Hype miterlebt, den Web-Hype der im Jahr 2000 rum plazte und die gesamte IT-Wirtschaft in Verruf brachte. Secound-Live wurde von vilen Medien schon als first Live ausgelebt usw. Was ich selber erfahren habe, dass eher immer die Leute gefragt waren, die sich nicht um all das kümmern. Ich denke da an den Jahrtausendwechsel als plötzlich Assembler-Programmierer gesucht wurden oder den immer noch hohen bedarf an Entwicklern in Cobol für Banken. Einen privater Trend, den ich selber gesetzt hab ist das Arbeiten mit vektorisierter Grafik, JSON, XML, XSL.
  • Von Anonym am 17.11.2017
    Kleine und mittelständische Unternehmen werden gar nicht die Kapazität haben, um sich diese Hype-Themen näher anzuschauen bzw. es ist viel zu risikoreich, auf diese zu setzen. Da geht man eher konservativ vor und wartet ein wenig ab und schaut, was sich dann durchsetzt. Wenn die vorhandenen Produkte gut funktionieren, warum sollte ein Unternehmen diese dann in Richtung von Hype-Themen umbauen? Kommt sicherlich auch auf die Branche an, speziell Webtechnologien sind ja teilweise sehr kurzlebig. Beim Lesen des Artikels fiel mir irgendwie sofort Gitlab ein … wie oft hat man dort schon das User Interface umdesigned und das JavaScript-Framework gewechselt. 😉 Vielleicht sind auch einfach die falschen Unternehmen auf den Konferenzen vertreten bzw. haben die nicht anwesenden Unternehmen kein Interesse etwas auf der Konferenz vorzustellen oder denken der Inhalt ihres Vortrags sei nicht innovativ genug.

  • Von Stefan Macke am 18.11.2017
    Ich denke, es ist Letzteres! Man ist ja auch schnell eingeschüchtert, wenn man mitbekommt, dass alle jetzt serverless arbeiten. Da kommt einem die Einführung eines Code-Review-Prozesses oder von TDD natürlich wenig innovativ vor…

  • Von Stefan Macke am 18.11.2017
    Hypalergiker. Sehr schön! 😀

Websites mit Programmierübungen

Veröffentlicht am 10.11.2017

Für Anwendungsentwickler ist es wichtig, den zentralen Skill des Berufs zu trainieren: Programmieren. Dafür gibt es viele Plattformen und Listen mit kleinen Problemen, an denen man sich als Einsteiger (oder auch durchaus als Profi) versuchen kann. Ich habe hier einige Websites zusammengestellt, die Interessierten Probleme zur Verfügung stellen. Teilweise mit Lösungen, damit man am Ende auch vergleichen kann, ob man es richtig gemacht hat. Da sollte für jedes Skill-Level etwas dabei sein! 🙂

  • Project Euler (Link: https://projecteuler.net/)
    Eine Plattform mit über 100 mathematischen Aufgaben, die immer schwieriger werden. Die Lösung eines Problems ist dann der „Schlüssel“ zum nächsten Level. Macht Spaß! 🙂
  • Train your Programmer (Link: https://trainyourprogrammer.de/)
    Verschiedene kleine Aufgaben in mehreren Programmiersprachen
  • Exercism (Link: http://exercism.io/)
    Community, die gerade Einsteiger ermuntert, sich an Programmieraufgaben zu versuchen. Über 30 Sprachen werden unterstützt.
  • A framework and lessons to learn java syntax and idioms in a logical sequence. (Link: https://github.com/matyb/java-koans)
    Viele kleine Koans zum Einstig in die Programmierung mit Java
  • Top 50 Java Programs from Coding Interviews (Link: http://javarevisited.blogspot.de/2017/07/top-50-java-programs-from-coding-Interviews.html)
    Eine tolle Liste mit häufig in Einstellungstests „abgefragten“ Algorithmen und Musterlösungen.
  • Category:Solutions by Programming Task (Link: http://rosettacode.org/wiki/Category:Solutions_by_Programming_Task)
    Eine riiiieeeesige Liste mit verschiedensten Programmieraufgaben in sehr vielen unterschiedlichen Sprachen.

Hast du weitere Ressourcen zum Üben der Programmierung? Mit welchen Plattformen übst du?

Kommentare

  • Von Stefan Lieser (Link: http://refactoring-legacy-code.net) am 10.11.2017
    Wir haben auf unserer CCD School Website einige Aufgaben zusammengestellt: http://ccd-school.de/coding-dojo/ Grüße vom Clean Code Developer Stefan Lieser
  • Von Stefan Macke am 11.11.2017
    Na klar, die dürfen nicht fehlen! 🙂 Danke!

Kontaktaufnahme mit fremden Entwicklern

Wie man auf Konferenzen mit anderen Entwicklern ins Gespräch kommt

Veröffentlicht am 03.11.2017

Nach der Softwareentwicklung im Mittelstand – SEROM (Link: https://serom.de) erwähnte einer meiner Azubis in unserem Bewertung von Auszubildenden (Evaluierungsbögen) – Anwendungsentwickler-Podcast #71 (Link: /bewertung-von-auszubildenden-evaluierungsboegen-anwendungsentwickler-podcast-71), dass er es schwierig fand, mit anderen – ihm fremden – Entwicklern ins Gespräch zu kommen. Das ging offensichtlich nicht nur ihm so. Am Abend bildeten sich auf der Konferenz schnell „Grüppchen“ der teilnehmenden Unternehmen. Die Kollegen sprachen eher miteinander, anstatt sich mit fremden Entwicklern über neue Ideen auszutauschen. Und damit geht leider ein wichtiger Punkt verloren, der Konferenzen so interessant macht: externer Input.

Die Kontaktaufnahem mit Fremden ist sicherlich schwierig für viele Menschen. Das ist kein Entwickler-spezifisches Problem! Aber nur wenn man diese Hürde nimmt, kann man von Konferenzen und User Groups mehr mitnehmen als die Fachvorträge vermitteln. Viele Konferenzteilnehmer beschwören sogar immer wieder, dass der sog. „Hallway-Track“ (also die Gespräche mit anderen Teilnehmern auf dem Flur zwischen den Vorträgen) interessanter ist, als die Vorträge selbst.

Dazu passt super dieser Artikel von John Sonmez: The Programmer’s Guide to Networking at a Conference (Link: https://simpleprogrammer.com/2015/04/20/the-programmers-guide-to-networking-at-a-conference/). Er gibt darin einige Tipps, wie man sich auf Konferenzen verhalten kann, um mit anderen Teilnehmern Kontakt aufzunehmen und sein Netzwerk auszubauen.

Für mich reichen eigentlich schon einige wenige Fragen, die ich mir auf die Konferenzen mitnehme, um mit fremden Entwicklern ins Gespräch zu kommen. Sie sind fast schon trivial, aber häufig scheitert die Kontaktaufnahme schon am Einstieg. Wie soll man z.B. am Mittagstisch eine Konversation starten? Mir reichen dafür eigentlich schon diese drei Fragen:

  • Wie fandest du den letzten Vortrag?
  • Was war für dich bislang der beste Vortrag?
  • Hast du schon irgendetwas aus den Vorträgen für deine Arbeit mitgenommen?

Damit sollte man – Interesse beim Gegenüber vorausgesetzt – ein Gespräch ins Rollen bekommen, denn alle Teilnehmer können definitiv etwas dazu sagen! Simpel, aber effektiv! 🙂

Hast du noch andere Vorschläge, wie man auch als zurückhaltender Mensch mit Anderen ins Gespräch kommt?

Kommentare

  • Von Manuel (Link: https://irimi.one) am 06.11.2017
    Viele Entwickler sind da gar nicht so kompliziert. Wenn man sich nähert, höflich begrüßt und nicht in eine wilde Diskussion platzt, kann man meistens einfach auch direkt fragen, was man wissen möchte oder was einen interessiert. Da sollte man einfach weniger Angst vor haben, denn viele Entwickler fahren auch zum „Netzwerken” zu solchen Konferenzen. Man sollte dann allerdings auch nicht gekränkt sein, wenn eine solche Gesprächseinladung abgelehnt wird.
  • Von Stefan Macke am 11.11.2017
    Das stimmt. Ich selbst bin auch immer froh, wenn ich angesprochen werde. Und meist ergeben sich dann tolle Unterhaltungen auf den Konferenzen.

Eine riiiiiiesige Liste mit Podcasts für Softwareentwickler

Veröffentlicht am 06.10.2017

Wenn du als Softwareentwickler Simple Programmer (Link: https://simpleprogrammer.com/) noch nicht kennst, hast du irgendetwas falsch gemacht! 😉 Man kommt eigentlich nicht an ihm vorbei. Ob in Simple Programmer Podcast (Link: http://simpleprogrammer.libsyn.com/), auf Konferenzen oder bei John Sonmez bei YouTube (Link: https://www.youtube.com/user/jsonmez): Der Mann produziert eine unfassbare Menge an Content. Ganz zu schweigen von seinen beiden Büchern Soft Skills:The software developer’s life manual (Link: http://amzn.to/2fFkHDv)* und The Complete Software Developer’s Career Guide: How to Learn Programming Languages Quickly, Ace Your Programming Interview, and Land Your Software Developer Dream Job (Link: http://amzn.to/2yz7zU2)*, die ich jedem Entwickler nur ans Herz legen kann.

*

*

Eine sehr empfehlenswerte Seite ist seine The Ultimate List Of Developer Podcasts (Link: https://simpleprogrammer.com/2016/10/29/ultimate-list-developer-podcasts/), die so ziemlich alle Podcasts auflistet, die für Softwareentwickler interessant sind. Gruppiert nach Themenschwerpunkten und Programmiersprachen lässt die Liste eigentlich keine Wünsche offen. Wer hier nicht fündig wird, programmiert bestimmt mit Agenda 2050 – Software AG (Link: http://2050.softwareag.com/de/)! 😉

Was sind deine Lieblingspodcasts für Softwareentwickler? Ich freue mich auf Empfehlungen, auch wenn meine persönliche Liste in BeyondPod Podcast Manager: Amazon.de: Apps für Android (Link: http://anwendungsentwicklerpodcast.de/BeyondPod)* schon längst überquillt.

Kommentare

  • Von Marcel am 08.10.2017
    Für automatisierte Podcast-Downloads, als Desktopanwendung über RSS-Abos, empfehle ich den Feedreader (Link zum Anbieter: http://feedreader.com/download ). Was an der Liste noch ganz cool wäre, eine Deutschsprachige Sammlung. Ich persönlich höre und lese keine einzige englische Seite. Ab und zu schau ich mir engl. YT-Programmier-Videos an, aber nur aus visuellen Aspekten. Zum Glück gibt es gegen diesen Trend der anglizistischen Ideologie noch vernünftige Universitäten, die ganze Blöcke von deutschsprachigen Videos aus mehreren Semestern in YT online stellen und viele private YTer https://www.youtube.com/channel/UCjTfChr0yyz4iZq0x12Q6xA https://www.youtube.com/user/JoernLoviscach/playlists?disable_polymer=1 https://www.youtube.com/playlist?list=PLy_veW0yWoxj7X75DyEBAEE3gm-N2ng4x https://www.youtube.com/user/TheDeepForces/playlists?disable_polymer=1 https://www.youtube.com/user/TheMorpheus407/playlists?disable_polymer=1 https://www.youtube.com/user/Brotcrunsher/playlists?disable_polymer=1 https://www.youtube.com/channel/UCeSlQgIAgY9dUdBdDWdZbSA/playlists?disable_polymer=1 https://www.youtube.com/user/ThytOS/playlists?disable_polymer=1 https://www.youtube.com/channel/UC6AqaL6fH91U5YhyUCI0ZOQ/playlists?disable_polymer=1 https://www.youtube.com/user/TchSupport/playlists?disable_polymer=1 https://www.youtube.com/user/SemperVideo/playlists?disable_polymer=1 Zur Informatikkultur gehört vor allem auch noch folgendes: https://www.youtube.com/user/netzpolitik/playlists?disable_polymer=1 CCC – https://www.youtube.com/user/mediacccde/playlists?disable_polymer=1 ( leider immer mehr engl. statt deutsche Vorträge ) http://chaosradio.ccc.de/chaosradio.html https://cre.fm/
  • Von Stefan Macke am 22.10.2017
    Wow! Danke für die Ergänzung! Langsam läuft meine To-Watch-Liste über! 😀

Die „Azubiflüsterin“ und Generation Z

Veröffentlicht am 22.09.2017

Auf dem Deutscher Ausbildungsleiterkongress (Link: https://www.deutscher-ausbildungsleiterkongress.de/) habe ich letztes Jahr zum ersten Mal von der „Azubiflüsterin“ Sabine Bleumortier bei Twitter (Link: https://twitter.com/SBleumortier) gehört. Seitdem schaue ich regelmäßig auf ihrer Website vorbei und nehme dabei immer wieder Anregungen für meinen Alltag als Ausbilder mit. Hier gibt sie z.B. einige Tipps für einen guten ersten Eindruck beim Einstieg in die Ausbildung – für Azubis, aber auch für Ausbilder!

  • Wie Azubis einen guten ersten Eindruck hinterlassen (Link: http://www.bleumortier.de/index.php/wie-azubis-einen-guten-ersten-eindruck-hinterlassen/)
  • Der erste Eindruck – auch für Ausbilder wichtig (Link: http://www.bleumortier.de/index.php/der-erste-eindruck-fuer-ausbilder-wichtig/)

Wir haben ALTE OLDENBURGER Krankenversicherung AG (Link: https://www.alte-oldenburger.de/) vor Kurzem den Informatik-Ausbildung bei der ALTE OLDENBURGER (Link: https://www.alte-oldenburger.de/karriere/ausbildung/informatik.html) auf unserer Website aktualisiert und dabei habe ich mir u.a. bei Frau Bleumortier einige Inspirationen geholt. Hier gibt sie z.B. Tipps für Ihren Ausbildungs-Blog (Link: http://www.bleumortier.de/index.php/tipps-fuer-ihren-ausbildungs-blog/). Wir haben zwar (noch) keinen Azubi-Blog für das Unternehmen, aber zwei meiner aktuellen Azubis (Jonas Hellmann (Link: https://blog.jonas-hellmann.de/) und Vincent Droppelmann (Link: https://pergman.de/blog/)) betreiben jeweils ihre private Website, auf der sie auch Fachartikel veröffentlichen, die sie im Rahmen der Ausbildung geschrieben haben. Und unsere aktuellen Azubis stellen sich nun immerhin auch mit einem kleinen Steckbrief auf unserer Website vor.

Auch zum Umgang mit der „Generation Z“, dich sich jetzt schon seit ein paar Jahren in die Ausbildung in den Unternehmen begibt, gibt Frau Bleumortier immer wieder Tipps und hält auch Vorträge zum Thema. Hier gibt es einen kurzen Ausschnitt bei YouTube: Hilfe, die Generation Z kommt! (Link: https://www.youtube.com/watch?v=ALl9TBkqM04)

Passend dazu kann ich abschließend noch diesen interessanten Artikel empfehlen, der die Werte und Wünsche der neuen Generation an die Arbeitgeber zusammenfasst: Generation Spaß adé, hier kommen die Realisten (Link: https://www.haufe.de/personal/hrmanagement/Generation-Spass-adé-hier-kommen-die-Realisten_80_417304.html).

Bist du selbst Azubi der „Generation Z“ und kannst die obigen Einstellungen bestätigen oder ihnen widersprechen? Und was hältst du als Ausbilder von den Tipps von Frau Bleumortier? Ich freue mich über Feedback!

Automatisierte Tests für Java-EE-Anwendungen

Automatisierte Tests für Java-EE-Anwendungen

Veröffentlicht am 15.09.2017

Auf der diesjährigen Developer Week habe ich über das Thema Tests all the way down – Automatische Tests für Java EE auf allen Schichten (Link: http://www.developer-week.de/Programm/Veranstaltung/(event)/21470) gesprochen. Blog von Sebastian Daschner (Link: https://blog.sebastian-daschner.com/) hatte bereits vor längerer Zeit die gleiche Idee und zeigt in diesem Video von der W-JAX mit Live-Coding, wie man Java-EE-Anwendungen automatisiert testen kann: Wer testet schon gerne? Kugelsicheres Java EE mit möglichst wenig Entwicklerfrustration (Link: https://vimeo.com/198187385).

Beide Vorträge zeigen, wie man alle üblichen Komponenten einer komplexen Anwendung in Java EE ohne manuellen Eingriff testen kann. Das Titelbild oben zeigt das Komponentendiagramm meiner Beispielanwendung für den Vortrag, die man sich bei GitHub anschauen kann: Automated tests for a Java EE 7 application (Link: https://github.com/StefanMacke/javaeetests). Ob Repositorys, Controller, Views oder Models – alle Bestandteile einer Webarchitektur lassen sich – sogar relativ einfach – testen. Und meist ist noch nicht einmal ein Tool dafür notwendig, sondern lediglich die saubere Trennung der Zuständigkeiten und der Einsatz von Dependency Injection.

Beim Aufbau der Testsuite sollte man sich allerdings an der Testpyramide orientieren: viele schnelle Unit-Tests (z.B. mit Junit (Link: http://junit.org/)), weniger langsamere Integrationstests (z.B. mit Arquillian (Link: http://arquillian.org/)) und sehr wenige pflegeintensive Oberflächentests (z.B. mit Selenium (Link: http://www.seleniumhq.org/)). Wenn man das berücksichtigt, denkt man automatisch schon beim Programmieren der kleinsten Einheiten daran, wie man sie gut in Isolation testen kann. Und das allein ist schon viel wert, da man automatisch bei einem modularen Softwaredesign landet.

Wie testest du deine Webanwendungen? Nutzt du Frameworks wie Selenium für Oberflächentests oder beschränkst du dich auf Unit-Tests?

Wordpress-Plugins

WordPress-Plugins

Veröffentlicht am 08.09.2017

Fachinformatiker Anwendungsentwicklung betreibe ich mit WordPress (Link: https://de.wordpress.org/) (wie gefühlte 90% der Blogs da draußen auch). Das System allein ist schon sehr mächtig, aber man kann es darüber hinaus noch mit zahlreichen Plugins erweitern. In diesem Artikel stellt Andreas Hecht einige interessante Plugins vor: 10 WordPress-Plugins, die jeder Seitenbetreiber haben sollte (Link: https://www.drweb.de/magazin/10-wordpress-plugins-die-jeder-haben-sollte/).

Ich selbst habe die Hälfte der genannten Plugins im Einsatz (aber ich verrate nicht welche :-P). Zusätzlich empfehle ich persönlich WP-Markdown (Link: https://wordpress.org/plugins/wp-markdown/). Ich schreibe alle meine Artikel und Podcast-Shownotes mit dieser leicht zu erlernenden Plain-Text-Sprache. Und da Markdown von vielen wichtigen Plattformen und Tools unterstützt wird (z.B. Eclipse, GitHub), kann ich nur jedem Azubi ans Herz legen, es ebenfalls zu lernen (wenn man es überhaupt lernen muss, bei der markdown.de (Link: http://markdown.de/). Aber dazu habe ich bereits vor einiger Zeit etwas geschrieben: Warum ich Markdown liebe.

Meine aktuellen Azubis Blog von Jonas (Link: https://blog.jonas-hellmann.de/) und Blog von Vincent (Link: https://pergman.de/blog/) setzen übrigens auch auf WordPress. Falls du auch einen (Azubi-)Blog betreibst, schreib mir doch einen Kommentar. Ich bin immer auf der Suche nach weiteren Websites für den Feedreader! 😀

Nutzt du WordPresse für deine Website? Wenn ja, welche Plugins kannst du mir empfehlen? Und wenn nicht, welche Software setzt du stattdessen ein und warum?

Kommentare

  • Von Marcel am 08.09.2017
    Ich betreibe seit vielen Jahren Wikiseiten mit Mediawiki. Möchte diese Möglichkeit nicht tauschen müssen. WP habe ich bisher nie richtig eingesetzt. Ich hatte mal ein sehr negatives Erlebnis mit einem gehackten CMS, bei den ich den Angriff nachvollziehen aber nicht beheben konnte. Seit dem wanke ich noch in meiner Entscheidung Informationen mit Artikelkarakter mit WP zu veröffentlichen. Aber wer weis .. 😉

Die beste Programmiersprache

Die beste Programmiersprache

Veröffentlicht am 28.07.2017

In diesem Artikel von Artem Chistyakov geht es um die interessante Frage nach der besten Programmiersprache: The language of programming (Link: https://temochka.com/blog/posts/2017/06/28/the-language-of-programming.html). Allerdings nicht um das, was du jetzt wahrscheinlich denkst. Er vergleicht nicht etwa Java und C# oder Python und Ruby miteinander, sondern bezieht sich tatsächlich auf die Sprache, die der Entwickler nutzt, um z.B. Variablen oder Methoden zu benennen, also Englisch oder Deutsch (bzw. Russisch in seinem Fall).

Der Artikel hat mich stark an meine eigene Arbeit erinnert. Wir entwickeln unsere Kernsysteme nämlich auch auf Deutsch. Das führt zwar zu seltsamen Konstrukten wie getAlter(), die für andere Entwickler ein No-Go sind. Aber in unserer Domäne – der privaten Krankenversicherung – lassen sich nicht alle Fachbegriffe sinnvoll ins Englische übersetzen. Und wenn doch, versteht der Fachbereich sie wahrscheinlich nicht mehr, da er gewohnt ist, deutsche Begriffe zu verwenden.

Ich habe mich inzwischen schon an die Benennung gewöhnt und sehe den klaren Vorteil, dass sofort und unmissverständlich jedem Leser klar ist, was gemeint ist. Dafür nehme ich diese „uncoole“ Konvention gerne in Kauf. Denn wie Martin Fowler schon in Martin Fowler – Refactoring: Improving the Design of Existing Code (Affiliate)* sagte:

Any fool can write code that a computer can understand. Good programmers write code that humans can understand.

Welche „Sprache“ benutzt du bei der Programmierung? Nutzt du Englisch oder eine andere Sprache? Was sind die Gründe dafür?

Kommentare

  • Von pro-grammr am 25.08.2017
    Ich habe bis jetzt immer Englisch benutzt. Aber einen besseren Grund als dass jeder meinen Code so zumindest verstehen kann, hatte ich auch noch nicht. In meinem Betrieb benutzen wir auch Englisch und wir hatten auch schon Mitarbeiter, die dein Wort Deutsch konnten. Leider auch kaum Englisch wie sich herausgestellt hat… Da hat unsere Konvention dann auch nicht viel geholfen.
  • Von Stefan Macke am 26.08.2017
    Oh man 😀 Ja, es ist wohl schwierig, einen allgemeinen Vorschlag zu machen. Es kommt immer auf das Unternehmen und vor allem auch die Beteiligten an.

Tipps für Code-Reviews

Tipps für Code-Reviews

Veröffentlicht am 19.05.2017

Meine Studentin führt gerade bei uns im Unternehmen eine kleine Studie zum Thema Code-Reviews durch. Passend dazu habe ich heute diese interessante Liste als Empfehlung: Best Practices for Code Review | Learn Code Review (Link: https://smartbear.com/learn/code-review/best-practices-for-peer-code-review/).

Es geht um 10 Tipps, die Code-Reviews effektiver machen. So wird z.B. empfohlen, max. 500 Zeilen Code pro Stunde zu reviewen (was ich persönlich etwas wenig finde), Checklisten zu verwenden und eine positive Kultur unter den Entwicklern aufzubauen, die Code-Reviews ermöglicht oder sogar unterstützt. Die meisten Punkte kann ich nach der Auswertung der ersten Ergebnisse unseres Praxistests und auch durch die Erfahrungen beim Review des Codes meiner Azubis absolut bestätigen.

Das erste Feedback zum Code-Review bei unseren Kollegen war sehr positiv. So haben z.B. fast alle Teilnehmer (Reviewender und Gereviewter!) etwas dabei gelernt, sowohl technisch, als auch fachlich. Außerdem haben wir als konkretes Ergebnis des Experiments schon eine lange Liste an Coding-Standards zusammengestellt, an die wir uns in Zukunft halten wollen.

Ich persönlich glaube, dass Code-Reviews eine günstige, einfach umzusetzende und lehrreiche Möglichkeit sind, um Code deutlich in seiner Qualität zu steigern! Nicht nur Azubi-Code sollte regelmäßig einer Prüfung unterzogen werden. Auch die Programme „fertiger“ Entwickler sind nicht perfekt und können fast immer optimiert werden.

Führt ihr bei euch im Unternehmen Code-Reviews durch? Wenn ja, was hast du dabei schon gelernt? Wenn nein, warum nicht? Es wird Zeit!

Wer pflegt uralten Legacy-Code?

Wer kümmert sich um Uralt-Code? Rentner!

Veröffentlicht am 12.05.2017

Entwickelst du total moderne Systeme mit Java, C# oder Ruby? Oder baust du eine ultracoole Webanwendung mit React oder Angular? Es könnte gut sein, dass diese Programme auch in einigen Jahrzehnten noch im Einsatz sind. Immerhin gibt es weltweit auch heute noch mehrere Milliarden (!) Zeilen COBOL-Code, der Kernprozesse in großen Konzernen, Banken und Versicherungen steuert.

Dieser interessante Artikel über die „aussterbenden“ COBOL-Entwickler zeigt, wie sehr die Wirtschaft von diesen beim Entwicklernachwuchs unbeliebten Programmiersprachen und -plattformen abhängig ist: Banks scramble to fix old systems as IT ‚cowboys‘ ride into sunset | Reuters (Link: http://www.reuters.com/article/us-usa-banks-cobol-idUSKBN17C0D8). Da werden Rentner aus dem verdienten Ruhestand zurückgeholt, um die Systeme zu korrigieren bzw. weiterzuentwickeln, die sie vor 40 Jahren programmiert haben. An eine Ablösung ist aus Kosten- und Zeitgründen oftmals nicht zu denken. Welche Bank tauscht schon „einfach mal so“ ihr Kernsystem aus, über das (seit Jahren verlässlich) Millionen von Transaktionen täglich laufen?

Spannend finde ich insbesondere, dass auch ich mit einer Programmiersprache arbeite, die mit COBOL vergleichbar ist, sowohl was das Programmiermodell angeht, als auch die Einsatzgebiete: Agenda 2050 der Software AG (Link: http://2050.softwareag.com/de/). Vor kurzem haben wir Erfahren Sie wie die Versicherung ALTE OLDENBURER den Generationswechsel vollzogen hat (Link: https://www.youtube.com/watch?v=YmDOXGHbYV4) darüber gedreht, wie wir Website der ALTE OLDENBURGER Krankenversicherung AG (Link: https://www.alte-oldenburger.de) auch Blog von Jonas Hellmann (Link: https://blog.jonas-hellmann.de/) an die Sprache heranführen und dafür sorgen, dass uns nicht das gleiche Schicksal blüht wie den Unternehmen im Artikel.

Kurz zusammengefasst: Wir setzen auf die Ausbildung im eigenen Unternehmen! Und das wir in diesem Bereich sehr engagiert sind, siehst du ja an dieser Website! 🙂

Arbeitest du mit topmodernen Programmiersprachen oder musst du auch ein „Legacy-System“ betreuen? Welche Strategien hat dein Unternehmen, um den Nachwuchs zu sichern?

Das Traveling-Salesman-Problem

Das Traveling-Salesman-Problem

Veröffentlicht am 05.05.2017

Es gibt einige „berühmte“ Programmierprobleme, von denen jeder Entwickler bereits einmal gehört haben sollte. Das Travelling-Salesman-Problem ist sicherlich eines der bekanntesten. Ein Handlungsreisender muss eine bestimmte Anzahl an Orten besuchen und der kürzeste Weg zwischen all diesen Punkten wird gesucht.

Was sich nach einer lächerlich einfachen Aufgabe anhört, die man mit einer simplen for-Schleife lösen könnte, stellt sich bei genauerer Betrachtung als unlösbares Problem heraus. Denn die schiere Anzahl an Kombinationsmöglichkeiten bei einer größeren Anzahl an Orten ist für Computer in endlicher Zeit nicht berechenbar. Schon bei 20 zu besuchenden Orten gibt es 20! = 2.432902E+18 verschiedene Möglichkeiten für eine Reihenfolge.

Daher benötigt man andere Ansätze, um solche Probleme zu lösen. Bei Baeldung gibt es ein schönes Beispiel für die Programmierung des TSPs mit sogenannten evolutionären Algorithmen: The Traveling Salesman Problem in Java | Baeldung (Link: http://www.baeldung.com/java-simulated-annealing-for-traveling-salesman). Diese Algorithmen bedienen sich bei bekannten Abläufen aus der Natur, zum Beispiel der Evolution, um scheinbar unlösbare Probleme näherungsweise zu lösen. Der Artikel gibt einen kurzen Einstieg in diese Thematik und zeigt eine Beispiellösung in Java.

Ich selbst lasse meine Studierenden in einem Tutorium zum Thema Produktionsplanung auch immer ein Referat über evolutionäre Algorithmen halten. Diese Ansätze bei der Programmierung sind äußerst spannend und haben mit der üblichen imperativen Herangehensweise an Probleme nicht mehr viel zu tun. Daher denke ich, dass jeder Entwickler etwas dabei lernen kann, wenn er mal eine völlig andere Lösung ausprobiert.

Musstest du schon einmal solche „harten“ Probleme lösen? Oder programmierst du hauptsächlich gut umsetzbare Algorithmen?

Kommentare

  • Von Lycea am 06.07.2017
    Hallo Stefan, bei meiner Arbeit habe ich hab und an auch ein Paar harte Nüsse zu knacken aber die meisten dinge lassen sich irgendwann nach gewisser arbeit Lösen. Das schwierigste was ich gefühlt umgesetzt habe war aber für mich selbst und nicht bei der Arbeit. Ich programmiere Hobbymäßig an einem Framework zum später Spiele einfach zu entwickeln als „kleines“ Projekt. Das letzte was ich dabei erstellt habe war ein kleines Modul welches dazu dient eine Karte besser eine Art Dungeon prozedural zu erstellen. Dies ist eigentlich ein gigantischer Algorithmus der aus mehreren kleinen Unterschritten besteht. Dabei habe ich gemerkt wie komplex manche Dinge dieser Art werden können. Aber wenn man sich an etwas derartigem versucht lernt man viele neue Dinge hinzu welche bei anderen Projekten ob Arbeit oder Hobby weiterhelfen können . Grüße Lycea

  • Von Stefan Macke am 06.07.2017
    Hallo Lycea,

    ab und an darf man ja auch mal ein bisschen knabbern an einem Problem. Muss ja auch herausfordernd bleiben unser Job 😉 Wobei die Spieleprogrammierung natürlich schon sehr anspruchsvoll ist!

    Viele Grüße! Stefan

Design-Patterns und Refactorings

Refactorings und Design Patterns

Veröffentlicht am 21.04.2017

Es gibt einige tiefergehende Konzepte, die jeder Softwareentwickler kennen sollte. Design-Patterns und Refactorings gehören sicherlich dazu.

Die Website Design Patterns & Refactoring (Link: https://sourcemaking.com/) (Danke an Blog von Markus Amshove (Link: https://amshove.org/) für den Tipp!) bietet eine fantastische Übersicht über zahlreiche Design-Patterns, Anti-Patterns und Refactorings. Wenn du Lust auf ansprechend visualisierte Patterns hast und schon immer einmal wissen wolltest, wofür man eigentlich einen Builder Design Pattern (Link: https://sourcemaking.com/design_patterns/builder) braucht, dann schau doch mal auf der Seite vorbei. Gerade auch die vielen Refactorings, die dort beschrieben sind, werden bei deiner täglichen Arbeit sicherlich hilfreich sein.

Die jeweiligen Themen sind mit lustigen Grafiken illustriert und man kann sie sicherlich besser lesen als die klassische Literatur zum Thema. Auch wenn ich dir als Anwendungsentwickler empfehlen würde, die beiden folgenden Klassiker trotzdem zu lesen, stellt die Website sicherlich einen spannenderen Einstieg in die Themen bereit. Und auch als Nachschlagewerk für Zwischendurch kann ich sie definitiv empfehlen!

Die „Bibel“ der Refactorings stammt ganz klar von Martin Fowler:

Martin Fowler - Refactoring: Improving the Design of Existing Code (Affiliate)*

Und Design-Patterns wurden quasi mit diesem Buch von der Gang of Four „erfunden“:

Design Patterns - Elements of Reusable Object-Oriented Software (Affiliate)*

Setzt du bei deiner täglichen Arbeit Design-Patterns und Refactorings ein? Welche Refactorings verwendest du am häufigsten?

Uncle Bobs Transformation Priority Premise

Uncle Bobs Code-Transformationen beim TDD

Veröffentlicht am 14.04.2017

Durch das Buch 99 Bottles — Sandi Metz (Link: https://www.sandimetz.com/99bottles/) – das ich übrigens absolut empfehlen kann – bin ich auf einen recht alten Blogartikel von „Uncle Bob“ aufmerksam geworden: The Transformation Priority Premise | 8th Light (Link: https://8thlight.com/blog/uncle-bob/2013/05/27/TheTransformationPriorityPremise.html). Der Autor von Robert C. Martin – Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)* erklärt darin eine Reihe von „Transformationen“, die der mit TDD entwickelte Produktivcode durchläuft, während man von der einfachsten möglichen Lösung für den aktuell fehlschlagenden Test zur generischen Lösung des eigentlichen Problems kommt.

Er vergleicht diese Transformationen mit den allseits bekannten Martin Fowler – Refactoring: Improving the Design of Existing Code (Affiliate)*:

However refactorings are used to transform the structure of code without altering its behavior. These transformations are used in order to change the behavior of code. In particular, we use these transformations to make failing tests pass.

Die Liste der Transformationen enthält Vorgänge wie „null in Konstante ändern“, „Skalar in Array ändern“ oder „if in while ändern“. Diese Transformationen sollten beim Programmieren des Codes unter Test am besten der Reihe nach durchlaufen werden, um den Code Schritt für Schritt komplexer werden zu lassen.

Eine gute Richtlinie für Einsteiger in TDD! Die Liste kann als Vorlage dienen, gerade wenn man zu Beginn noch unsicher ist, wie die nächste Version des zu entwickelnden Algorithmus aussehen könnte.

Wie gehst du beim Programmieren deines Produktivcodes vor? Hältst du dich an die strikte Vorgabe von TDD?

Hippes Zeug bei der Softwareentwicklung

Hippes Zeug bei der Softwareentwicklung

Veröffentlicht am 24.03.2017

Ich mag moderne Softwareentwicklungsmethoden. Und ich mag auch moderne Softwarearchitekturstile. Ich bin der Meinung, dass man sich alle neuen Entwicklungen anschauen sollte und dann selbst entscheiden muss, ob die Technologien oder Ideen zur eigenen Software und dem Unternehmen passen. Eine One-Size-Fits-All-Lösung – die berühmte „Silver Bullet“ – gibt es nicht.

Deswegen finde ich es immer unglücklich, dass gerade auf den großen Konferenzen immer wieder bestimmte Technologien als Allheilmittel oder „das hippe Zeug“ verkauft werden. Aktuell sind das wohl die beliebten Microservices, REST, Single Page Apps (SPA) oder Reactive Programming. Das sind alles richtig coole Ideen und für bestimmte Einsatzzwecke sind es tatsächlich die perfekten Lösungen. Aber nunmal nicht für jedes Projekt, jede Plattform und jedes Unternehmen.

Schön, dass es abseits des Trends zu diesen Themen hin und wieder auch einmal eine kritische Auseinandersetzung mit ihnen gibt. Dieser Artikel von Silvia Schreier setzt sich z.B. mit REST und SPAs auseinander: REST und SPAs sind nicht immer die Lösung (Link: https://jaxenter.de/rest-spa-webarchitektur-43004). Er schließt mit einer schönen, kompakten Übersicht über die Vor- und Nachteile verschiedener Technologien, anhand derer man selbst bewerten kann, ob sie zur eigenen Software passen oder nicht.

Mein eigener Vortrag auf der SEROM – Softwareentwicklung im Mittelstand (Link: https://serom.de/) hatte das gleiche Ziel: Vor-, aber eben auch die Nachteile der Technologien aufzuzeigen: Wer braucht eigentlich Microservices – Aktuelle Trends der Softwareentwicklung in der Praxis (Link: https://www.slideshare.net/StefanMacke/wer-braucht-eigentlich-microservices-aktuelle-trends-der-softwareentwicklung-in-der-praxis).

Er wurde vom Publikum – den bisherigen Rückmeldungen nach – leider hauptsächlich als Rant gegen Microservices und Co. aufgefasst. Das ist aber wie beschrieben gar nicht meine Absicht. Stattdessen sollte man sich als Softwareentwickler mit den potentiellen negativen Punkten auseinandersetzen und nach einer reiflichen Überlegung eine bewusste Entscheidung treffen.

Dass dies in der Praxis häufig nicht geschieht, sehe ich auch in vielen IHK-Prüfungen. Es werden z.B. die vorgegebenen Technologien gar nicht hinterfragt oder sogar für das Abschlussprojekt völlig neue Frameworks verwendet, einfach nur, weil sie „cool“ sind. Zumindest bekommt man diesen Eindruck, wenn ein Prüfling eine komplette Anwendung mit A JavaScript library for building user interfaces – React (Link: https://facebook.github.io/react/) und Read Me · Redux (Link: http://redux.js.org/) umsetzt, aber weder das eine, noch das andere erklären kann…

Welche modernen Technologien setzt ihr in deinem Unternehmen ein? Weißt du, warum ihr sie einsetzt und was ihre Vor- und Nachteile sind?

Kommentare

  • Von Simon U. am 20.06.2017
    Hallo Stefan, ich arbeite bei einem Bahnunternehmen als Softwareentwickler und stehe häufig vor dem Problem, die passende Herangehensweise an eine Aufgabe erst finden zu müssen. Wie du es bereits andeutest, ist es wichtig, alle Möglichkeiten abzuwägen und nicht nur die, die vielleicht gerade im Trend sind. Ich unterstütze deine Meinung auch in dem Punkt, dass sich viele Neuunternehmer von diesen Trends beeinflussen lassen und für ihr Unternehmen die falsche Struktur o.ä. wählen, weil diese Struktur gerade „jeder“ hat.. Danke für den interessanten Beitrag. Lg Simon

  • Von Stefan Macke am 21.06.2017
    Hallo Simon,

    gern geschehen! 🙂 Ich finde neue Technologien auch super spannend, aber man muss immer abwägen, ob sie für das konkrete Problem wirklich die beste Lösung darstellen.

    Viele Grüße! Stefan

Functional Core und irgendeine Shell

Functional Core… und irgendeine Shell

Veröffentlicht am 10.03.2017

Funktionale Programmierung ist ziemlich cool! B-) Oder zumindest sind einige Features dieser Art der Programmierung sehr hilfreich bei der täglichen Arbeit. Nicht umsonst stellen immer mehr objektorientierte Sprachen auch funktionale Bestandteile bereit. Beispiele sind LINQ in C#, Blöcke in Ruby oder Streams in Java. Auch die Idee von Map/Filter/Reduce für die Arbeit mit Listen oder allgemein Datenmengen zähle ich jetzt mal dazu.

Gary Bernhardt hat in einem Screencast schon 2012 sein Konzept des Functional Core, Imperative Shell (Link: https://www.destroyallsoftware.com/screencasts/catalog/functional-core-imperative-shell) vorgestellt: Die Domäne der Software nutzt funktionale Programmierung und ihre Vorteile – wie z.B. Immutability und Seiteneffektfreiheit – ohne Zugriff auf die Infrastruktur. Und drumherum liegt eine „normale“ Schicht, die z.B. eine GUI bereitstellt, auf die Datenbank zugreift oder Webseiten generiert. Eben alles, was im funktionalen Kontext als „unrein“ zu bezeichnen wäre.

Giovanni Lodi greift in seinem Talk die Idee auf und ergänzt sie um eine weitere moderne Komponente: Functional Core Reactive Shell (Link: http://www.mokacoding.com/blog/functional-core-reactive-shell/). Anstatt der „imperativen“ Shell verwendet er direkt eine reaktive. Falls du mit dem Begriff Reactive Programming noch nichts anfangen kannst, gibt es hier – analog zum agilen Manifest – das Das Reaktive Manifest (Link: http://www.reactivemanifesto.org/de).

Ich finde beide Ideen sehr interessant, auch wenn ich persönlich mit reaktiver Programmierung noch nichts zu tun hatte. Aber die Trennung zwischen einer „reinen“ Domäne und der „unreinen“ Außenwelt dürfte die automatischen Tests deutlich erleichtern, z.B. weil Unit-Tests ohne Mocks mehr nötig sind.

Verwendest du in deinem Code schon funktionale Konzepte? Oder setzt du sogar schon auf einen „funktionalen Kern“? Was sind deine Erfahrungen mit dieser Art zu programmieren?

Unit-Tests ohne Mocks

Unit-Tests ohne Mocks

Veröffentlicht am 03.03.2017

Mocking ist beim automatischen Test von Software heutzutage allgegenwärtig. Es ist eine sehr gute Idee, bei Unit-Tests auf jegliche Form der Infrastruktur – Netzwerk, Datenbank, Dateisystem usw. – zu verzichten, um die Tests schnell und zuverlässig zu machen. Aber man kann es mit dem Mocking auch übertreiben. Umfangreiche Setups und schwer zu verstehende Tests sind die Folge. Auch werden die Tests ggfs. sehr schwierig anzupassen, wenn umfangreiche Abhängigkeiten zu Mocks bestehen, die ja alle erst einmal konfiguriert werden müssen.

Ken Scambler zeigt in diesem interessanten Artikel, dass man anstatt Mocks zu verwenden besser versuchen sollte, auf Seiteneffekte im zu testenden Code (denn für nichts anderes braucht man die Mocks) zu verzichten: To Kill a Mockingtest (Link: http://rea.tech/to-kill-a-mockingtest/). Der dabei entstehende Code entspricht eher dem funktionalen Ansatz von seiteneffektfreien, „reinen“ Funktionen, die einfach durch Vergleich des Ergebnisses mit definierten Werten (also einem simplen Unit-Test) auf Korrektheit geprüft werden können.

Und in Anlehnung an das – wirklich Growing Object-Oriented Software, Guided by Tests (Freeman/Pryce) – Buch Growing Object-Oriented Software, Guided by Tests – Amazon (Affiliate)* zeigt Vladimir Khorikov in diesem Artikel, wie er das komplexe Beispiel aus dem Buch implementieren würde, ohne Mocks für die Tests nutzen zu müssen: Growing Object-Oriented Software, Guided by Tests Without Mocks – Enterprise Craftsmanship (Link: http://enterprisecraftsmanship.com/2016/07/05/growing-object-oriented-software-guided-by-tests-without-mocks/). Absolut spannend zu sehen, insbesondere, wenn man das Buch kennt. Er zeigt noch einmal eine ganz neue Sicht auf das Codedesign.

Ich werde – angeregt durch die obigen Artikel – in Zukunft jedenfalls versuchen, auf Mocks zu verzichten. In meinen eigenen Projekten habe ich selbst nämlich schon recht komplexe Setups für Mocks nutzen müssen und irgendwann fast den Überblick verloren. Spätestens wenn man an diesem Punkt ist, sollte man sich Gedanken machen, ob es nicht auch anders geht.

Verwendest du Mocks in deinen Unit-Tests? Welche(s) Framework(s) verwendest du dafür?

Stärkung der Rückenmuskulatur

Übungen zur Stärkung der Rückenmuskulatur

Veröffentlicht am 24.02.2017

Ich habe hier im Review: Sculpt Ergonomic Keyboard – Ungeeignet für Power-User und auch im Ergonomie am Arbeitsplatz – Anwendungsentwickler-Podcast #60 ja schon häufiger über Ergonomie gesprochen, weil mich das Thema sehr interessiert und ich der Meinung bin, dass gerade Softwareentwickler nicht genug auf ihre Gesundheit am Arbeitsplatz achten können. Wir sitzen täglich stundenlang am Computer und bewegen uns viel zu wenig. Vor einiger Zeit habe ich schon einmal diese Infografik von Ergotopia verlinkt, die die Auswirkungen von zu langem Sitzen zeigt: Infografik: Sitzen kann tödlich sein! Bewegungsmangel Folgen.. (Link: http://www.ergotopia.de/infografik-sitzen-kann-toedlich-sein) Inzwischen nutze ich daher z.B. regelmäßig einen Stehschreibtisch (bzw. die deutlich günstigere Variante eines Laptopständer als kostengünstige Alternative zum Stehschreibtisch).

Aber ich könnte definitiv noch mehr tun, um langfristigen Haltungs- und Gesundheitsschäden vorzubeugen. Der Ergotopia-Blog ist eine gute Quelle für einfache Übungen zur Entspannung oder Stärkung der Muskulatur. Ganz konkret kann ich diesen Artikel mit Übungen für die Rückenmuskulatur empfehlen: Rückenmuskulatur stärken – 12 hilfreiche Übungen (Link: http://www.ergotopia.de/blog/rueckenmuskulatur-staerken). Die Artikel im Blog sind immer sehr umfangreich und gut recherchiert. Ich habe ihn schon seit Langem in meinem Feedreader.

Die gezeigten Übungen kann man z.B. gut mit der Staffan Noteberg – Pomodoro Technique Illustrated (Affiliate)* verbinden. Da man dabei alle 25 Minuten eine kurze Arbeitspause einlegt, bietet es sich an, einfach ein paar kurze Übungen zu machen. Denn Sport nach der sitzenden Arbeit hebt die Nachteile des dauerhaften Sitzens nicht auf. Stattdessen sollte man besser regelmäßig kurze Unterbrechungen einplanen, um die Muskulatur nicht zu lange einseitig zu belasten.

Für zuhause habe ich mir vor Kurzem einen recht günstigen GYRONETICS E-Series Rückentrainer klappbar Hyperextension / Bauchtrainer mit gepolsterter Beinfixierung (Affiliate)* zugelegt, auf dem ich täglich ein paar „umgedrehte Situps“ mache (die wohl eigentlich „Workout “Rücken-Kraft”: Rumpfheber – FIT FOR FUN (Link: http://www.fitforfun.de/sport/fitness-studio/ruecken-kraft-video/ruecken-kraft-rumpfheber_vid_1641.html)“ heißen).

GYRONETICS E-Series Rückentrainer klappbar Hyperextension / Bauchtrainer mit gepolsterter Beinfixierung: Amazon.de: Sport & Freizeit (Affiliate)*

Er ist relativ kompakt und nimmt nicht allzu viel Platz weg. Ich persönlich nutze ihn lieber als eine Bodenmatte. Irgendwie bin ich zu faul für die Übungen auf dem Boden! 😀

Hast du noch weitere Tipps für Übungen oder Geräte zur Stärkung der Rückenmuskulatur? Dann immer her damit! Ich freue mich über deine Empfehlungen!

Fragen zu .NET im Fachgespräch oder Vorstellungsgespräch

Fragen zu .NET im Vorstellungs- und Fachgespräch

Veröffentlicht am 03.02.2017

Viele Beiträge hier im Blog sind recht Java-lastig, da ich selbst hauptsächlich mit Java arbeite. Aber natürlich ist die Ausbildung zum Anwendungsentwickler programmiersprachenunabhängig. Daher habe ich heute mal einen Link für alle .NET-Entwickler da draußen 🙂

Patrick Lorenz hat in einem Artikel für die dotnetpro (übrigens eine empfehlenswerte Zeitschrift) einige Fragen zusammengestellt, die er in Vorstellungsgesprächen seinen Bewerbern stellt. Das Thema ist natürlich .NET: Unnatürliche Auslese (Link: http://www.dotnetpro.de/workout/unnatuerliche-auslese-1184818.html).

Von string (C#-Referenz) (Link: https://msdn.microsoft.com/de-de/library/362314fe.aspx) vs. String-Klasse (System) (Link: https://msdn.microsoft.com/de-de/library/system.string(v=vs.110).aspx) über Erweiterungsmethoden (C#-Programmierhandbuch) (Link: https://msdn.microsoft.com/de-de/library/bb383977.aspx) und Null coalescing operator – Wikipedia (Link: https://en.wikipedia.org/wiki/Null_coalescing_operator) bis zum Global Assembly Cache – Wikipedia (Link: https://de.wikipedia.org/wiki/Global_Assembly_Cache) sind viele wichtige Sprach- und Plattformfeatures vertreten. Und auch neuere Features wie die String interpolation – Wikipedia (Link: https://en.wikipedia.org/wiki/String_interpolation) werden behandelt. Insgesamt eine tolle Liste, um sich auf Bewerbungsgespräche im .NET-Umfeld vorzubereiten.

Aber die Fragen könnten auch genau so im Fachgespräch zu einem .NET-Projekt gestellt werden. Daher meine Leseempfehlung, auch wenn du gerade (noch) nicht auf Jobsuche bist. Insbesondere die Unterscheidung von Wert- und Referenztypen ist ein beliebtes Thema – übrigens unabhängig von der verwendeten Programmiersprache. Daher gehe ich z.B. auch Das perfekte Fachgespräch (IHK-Prüfung zum Fachinformatiker Anwendungsentwicklung) (Link: http://dasperfektefachgespraech.de/) darauf ein.

Konntest du alle Fragen beantworten? Hast du noch weitere Fragen, die du auf der Liste ergänzen würdest?

Warum du eine Tastatur für 430 Euro brauchst

Warum du eine Tastatur für 430 EUR brauchst

Veröffentlicht am 27.01.2017

Seit Weihnachten bin ich auf der Suche nach einer neuen ergonomischen Tastatur. Letzte Woche habe ich hier das Review: Sculpt Ergonomic Keyboard – Ungeeignet für Power-User rezensiert. Sie gefällt mir aus verschiedenen Gründen leider nicht so gut bzw. sie ist meiner Meinung nach für den Alltagseinsatz als Softwareentwickler nicht geeignet.

Motiviert durch diesen Artikel von Avdi Grimm (den du vielleicht von den RR Episodes (Link: https://devchat.tv/ruby-rogues) kennst) habe ich mir nun ein Herz gefasst und mir die Advantage2 von Kinesis zugelegt: Why you should spend $350 on a computer keyboard | Virtuous Code (Link: http://www.virtuouscode.com/2016/10/06/why-you-should-spend-350-on-a-computer-keyboard/).

Diese super ergonomische Tastatur schlägt allerdings Kinesis KIN-ADVWUSBHY Advantage Tastatur (UK-Layout, USB) schwarz/silber (Affiliate)* zu Buche! Für diesen mehr als stolzen Preis sollte sie also schon perfekt sein!

Kinesis KIN-ADVWUSBHY Advantage Tastatur (UK-Layout, USB) schwarz/silber (Affiliate)*

Die Vorteile der Tastatur zähle ich hier jetzt mal nicht auf, da der obige Artikel das eigentlich schon sehr gut zusammenfasst. Ich habe die Tastatur nun seit einigen Tagen im Einsatz und musste tatsächlich das Tippen komplett neu lernen. Am ersten Tag habe ich nicht einen Satz fehlerfrei schreiben können. Allein die Tatsache, dass man die Leertaste nur mit dem rechten Daumen bedienen kann, und die entsprechende Taste für die linke Hand die Backspace-Taste ist, macht das Tippen für den ungeübten Anwender wie mich fast unmöglich.

Ich werde mich jetzt hier – anders als der Titel des Artikels vermuten lässt – nicht hinstellen und für Azubis mit kleiner Ausbildungsvergütung eine Tastatur für 430€ empfehlen. Sobald ich etwas länger mit der Kinesis gearbeitet habe, werde ich hier im Blog noch einmal ausführlich auf die Vor- und Nachteile eingehen. Das erste, was mir aber schon direkt aufgefallen ist, sind die fehlenden Tasten, die ich als Programmierer ständig benötige. So fehlen mir z.B. die AltGr– oder Einfg-Taste und auch die Kontextmenütaste ist mit Windows als Betriebssystem mehr als hilfreich. Mein erster Eindruck ist also alles andere als perfekt. 🙁

Welche Tastatur benutzt du aktuell? Hast du noch eine Empfehlung für eine ergonomische Tastatur für mich? Sie darf auch gerne etwas günstiger sein. 🙂

Kommentare

  • Von Thomas Schypior am 27.01.2017
    Hab leider auch noch keine gute Allround-Alternative zur Natural 4000 gefunden. Ein Freund hat sich eine ErgoDox zusammengebastelt. Die schaut ganz ähnlich aus, aber ich glaub da würd ich die Advantage2 vorziehen, schon wegen der Wölbung und der Handauflage. Aber wie ist das denn mit Remapping? Wenn dir AltGr oder Einfg fehlen, kannst du die bei der Advantage ja selbst umlegen, oder?

  • Von Stefan Macke am 27.01.2017
    Ja, das stimmt. Aber dann fehlen mir halt andere Tasten. Und die Umgewöhnung wäre noch krasser :-/ Dann könnte ich gar nicht mehr auf „normalen“ Tastaturen tippen…

    Das Remapping musste ich sogar schon anwenden für die Windows-Taste (die ich ständig brauche). Das hat zwar funktioniert, aber die Tastenbeschriftungen passen dann natürlich nicht mehr und bei Nutzung der eingebauten Tastaturlayouts werden alle eigenen wieder überschrieben.

  • Von Thomas Schypior am 27.01.2017
    Meh, Bummer! Hört sich dann eher nich so prickelnd an. Bin gerade auf das Matias Ergo Pro gestoßen. Das schaut ganz attraktiv aus. Gut, hat zwar keinen Nummernblock, aber ansonsten ist mir auf den ersten Blick noch kein Dealbreaker aufgefallen.

  • Von Stefan Macke am 28.01.2017
    Die steht als nächstes auf meiner ToTry-Liste 😉 Ist mit 260 EUR allerdings auch nicht gerade günstig :-/

  • Von Stefan Macke’s Gewissen am 01.02.2017
    Really, ein Artikel für einen 430€ Affiliate Link?

  • Von Stefan Macke am 01.02.2017
    Es geht mir nicht um den Link, sondern um die Tastatur. Ein ausführlicher Testbericht folgt demnächst. Ich teste gerade – und zwar aus rein privaten, ergonomischen Gründen und auf eigene Kosten – mehrere Tastaturen und möchte anderen Softwareentwicklern meine Erfahrungen mitteilen. Im Artikel habe ich ja sogar explizit von der Kinesis-Tastatur abgeraten.

    Und natürlich setze ich zu den Produkten Affiliate-Links (siehe auch Werbung auf dieser Seite (Link: /werbung-auf-dieser-seite/), da ich zusätzlich zu meiner investierten Freizeit für das Betreiben dieser Website sonst noch Geld für das Hosting oben drauf legen müsste :-/

  • Von Manuel (Link: http://manulicious.de/) am 07.02.2017
    Ich setze tatsächlich bei meiner Tastatur zum Arbeiten nicht so viel Wert auf Ergonomie, sondern mehr auf Einheitlichkeit. Mein privater Hauptrechner ist ein Thinkpad, also lag es nahe mir auch für den PC-Arbeitsplatz eine Tastatur zuzulegen, die der Notebooktastatur am nächsten kommt. Diese bietet Lenovo tatsächlich auch an (kein Affiliate Link ;-)): https://www.amazon.de/gp/product/B00CZ35ODI/ref=oh_aui_detailpage_o06_s00?ie=UTF8&psc=1 Dadurch, dass ich mich an den Trackpoint zur Cursornavigation gewöhnt habe, brauche ich auch gar keine Maus am Arbeitsplatz mehr. Außerdem kann man so beide Hände auf der Tastatur lassen, auch wenn man den Cursor verschieben muss. So bin ich etwas schneller. Ich schrieb oben explizit „zum Arbeiten“, weil ich das für meine freizeitliche Computernutzung (also zum Zocken mit den Kollegen) anders halte. Dort ist es mir wichtig auch gute Peripherie zu haben, die dem Zweck gerecht wird. Dann brauche ich eine Maus, die gut zu meiner „Hand-Form“ passt, und eine Tastatur mit besseren Anschlägen/Taster-Eigenschaften als die einer Notebooktastatur. Glücklicherweise habe ich keine Probleme mit einer Umgewöhnung, weil ich momentan eh nur wenig Zeit zum Daddeln finde, und daher am häufigsten die Notebook-Tastatur verwende.

  • Von Stefan Macke am 07.02.2017
    Ja, das ist auch eine gute Strategie. Ich habe auch genau aus dem Grund die Kinesis zurückgeschickt: Ich könnte dann nicht mehr zwischen Tastaturen wechseln. Entweder ich kann auf der Kinesis tippen oder auf der normalen Tastatur. Aber beides gleichzeitig würde nicht gehen, weil die ständige Umgewöhnung zu lange dauert.

    Dass Zocker besondere Anforderungen haben, ist natürlich klar. Wobei ich persönlich dafür schon auf ein Gamepad umgestiegen bin, weil mir das stundenlange (vielleicht war auch das das eigentliche Problem 😉 ) starre Halten der Maus bzw. von WASD schnell in den Arm zog. Und mit der ergonomischen Hardware zockt es sich tatsächlich nicht so gut. Mit einer vertikalen Maus wird so ein Headshot deutlich schwieriger! 😉

  • Von Tachiguro (Link: https://www.neo-layout.org/) am 12.02.2017
    Ich möchte auch mal was loswerden. ^^ Für eine Tastatur gebe ich keine 450€ oder auch „nur“ 200€ aus. Habe mich aber da richtig informiert und das was ich raus gefunden habe wird euch vlt. interessieren. Ich mache gerade eine Umschulung zum Anwendungsentwickler bin im 2 Semester und jetzt muss ich immer mehr und mehr tippen. Eine alte Verletzung am linken Handgelenk hat mich gezwungen nach etwas ergonomischen zu suchen da ich die Umschulung nicht abbrechen will. Ich habe um die 10 verschiedene Tastaturen ausprobiert und nix gefunden, dass das Handgelenk entlastet. Zufällig bin ich dann auf NEO 2.0 (Link: https://www.neo-layout.org/) gestoßen. Das ist ein Tastenlayout nach den Prinzip von Dvorak (wer es nicht kennt bitte googlen! (Link: https://www.google.de/#q=dvorak)) entwickelt. Ich benutze tipp10.de (Link: https://online.tipp10.com/de/training/) um das NEO 2.0 System (Link: https://www.neo-layout.org/) zu üben. Nach 4 Tagen bin ich bei 60 Zeichen gelandet mit 2 Fehlern im schnitt. Das beste: Mein Handgelenk beschwert sich beim NEO gar nicht. Lieg wohl daran das QWERTZ einfach nicht mehr Zeitgemäß ist …. Das Problem: Kann man verschiedene Tastenlayouts benutzen? Ja, es ist in einigen Ländern üblich mehrere Tastenlayouts zu benutzen z.b. ITler in Russland, Japan, China. usw. Mfg Tachiguro ò_ó

  • Von Stefan Macke am 12.02.2017
    Hallo Tachiguro,

    danke für den Tipp. Das normale Tastaturlayout ist sicherlich nicht das ergonomisch beste. Aber die Hardware macht auch definitiv einen großen Teil der gesundheitlichen Probleme aus. Daher teste ich fleißig weiter 🙂

    Mein Problem mit anderen Layouts ist die lange Umstellungsphase. Das habe ich schon bei der Kinesis gemerkt, bei der nur wenige Tasten anders sind. Wenn du es natürlich hinbekommst, an all deinen Arbeitsgeräten zuhause und auf der Arbeit das neue Layout zu nutzen, ist das Problem hinfällig. Bei mir geht das so leider nicht. Daher bleibe ich beim alten Layout.

    Viele Grüße! Stefan

  • Von Ulla am 01.03.2017
    Ulla Hallo Stefan, wieso sagst du, das sie crtl und alt Tasten fehlen? Sie sind dem Bild oben abgebildet. Kannst du das erklären. Und ich frage mich gerade, wenn man 30 Jahre Praxis hat, ob dass dann wohl auch so schwierig ist mit einem spontanen Benutzen einer normalen Tastatur. Kannst du das einschätzen? Interessante Seite. Ich bin Ergotherapeutin und informiere mich auch gerade. Ist tatsächlich sehr schwer was Gutes zu finden. repetitive-strain-injury.de die dort dargestellte Tastatur finde ich bestechend gut, aber man sieht nicht, wie es sich beim Tippen anfühlt, ob sie stabil liegt und einen grossen Nachteil finde ich, wenn sie nicht nach hinten kippbar oder lagerbar ist. Schönen Gruss, Ulla

  • Von Stefan Macke am 01.03.2017
    Hallo Ulla,

    Ctrl und Alt sind da, aber AltGr (braucht man z.B. für @ und €) fehlt.

    Wie meinst du das mit den 30 Jahren? 30 Jahre an einer normalen Tastatur? Dann wird der Umstieg sehr schwierig, weil viele gewohnte Tasten an der falschen Stelle liegen.

    Und welche Tastatur meinst du genau? Auf der genannten Seite werden ja mehrere gezeigt. Die Microsoft 4000 habe ich z.B. schon jahrelang im Einsatz und kann sie weiterempfehlen (vor allem für den geringen Preis).

    Viele Grüße! Stefan

  • Von Yannick Schallenberg am 17.03.2017
    Ich benutze selbst das Microsoft Wireless Desktop 3000, also mit einer ganz normalen Standard Tastatur von Microsoft die ziemlich oft für Office benutzt wird. Sie hat zwar ein mega gutes Tippverhalten, aber mit der Zeit wird es in den Händen schon anstrengend, zusätzlich ist es beinahe unmöglich, die F-Tasten zu treffen ohne das man die falsche drückt. Die Suche nach einer passenden Tastatur, am besten direkt beleuchtet ist aber ziemlich schwierig von daher.

  • Von Stefan Macke am 17.03.2017
    Hallo Yannick,

    oh ja, das ist eine „Standardtastatur“. Da glaube ich gerne, dass die Hände das nicht lange mitmachen. Ich kann nur zu einer ergonomischen Tastatur raten. Eine wirklich gute Alternative für relativ wenig Geld ist immer noch das Microsoft Natural Ergonomic Keyboard 4000 (Affiliate)*. Allerdings hat die natürlich nicht den Charme einer beleuchteten „Gaming-Tastatur“ 😉

    Viele Grüße! Stefan

  • Von Yannick Schallenberg am 19.03.2017
    Hey Stefan, es soll ja keine Gaming Tastatur sein, da ich selbst so gut wie gar nicht am PC spiele, und was ich spiele, spiele ich mit einem Lenkrad… Ich dachte eher an die Alternativen von Logitech (Link: https://www.logitech.com/de-de/product/wireless-illuminated-keyboard-k800) , wobei es sehr gut sein kann, dass es das Natural Ergonomic Keyboard 4000 wird, vor allem nach deinem Review zum Nachfolger, welcher mir vorher sehr gefiel. Gruß, Yannick.

Die schnellste Website der Welt

Die schnellste Website der Welt

Veröffentlicht am 20.01.2017

In der heutigen Zeit, in der Mobilgeräte schon für die Mehrheit des Traffics im Internet verantwortlich sind, ist es umso wichtiger, dass wir als Software-Entwickler darauf achten, dass unsere Websites schnell laden und wenig Traffic verursachen. In diesem Artikel geht David Gilbertson auf 10 Dinge ein, die er beim Programmieren der – wie er selbst behauptet – schnellsten Website der Welt gelernt hat: 10 things I learned making the fastest site in the world (Link: https://hackernoon.com/10-things-i-learned-making-the-fastest-site-in-the-world-18a0e1cdf4a7#.8b50pr74t).

Der Artikel ist witzig geschrieben und enthält viele Praxistipps, die man als Entwickler von Websites direkt anwenden kann. Er verweist auf mehrere Tools und externe Websites, die objektiv bewerten können, ob sich das Ladeverhalten der eigenen Seite verbessert hat oder nicht. Allein der Einsatz dieser Tools ist das Lesen des Artikels schon wert.

David hat aber auch selbst mehrere Vergleichsdiagramme in den Artikel eingebaut, um konkrete Optimierungen vorher und nachher zu vergleichen. Er geht auch auf einige heute sehr verbreitete Features ein, wie z.B. das Rendern von HTML erst im Frontend anstatt das HTML direkt vom Backend ausliefern zu lassen. Auch das bei mir persönlich verpönte „Inlinen“ von CSS trägt offensichtlich durchaus dazu bei, die Seite schneller laden zu lassen (immerhin gibt es einen Request zur CSS-Datei weniger an den Server).

Ich persönlich habe ein paar interessante Anregungen aus dem Artikel mitgenommen, die ich in Zukunft beim Gestalten meine eigene Websites beachten werde. Vielleicht sollte ich die einzelnen Punkte auch direkt einmal für diese Seite durchgehen, da ich das Gefühl habe, dass ich hier noch einiges optimieren könnte. 🙂

Worauf achtest du bei der Gestaltung deine Websites? Ist Performance für dich ein wichtiges Kriterium?

Einführung in JUnit 5

Einführung in JUnit 5

Veröffentlicht am 13.01.2017

Aktuell setze ich ein kleines Java-Projekt um, das ich im Laufe dieses Jahres sicherlich auch hier zur Verfügung stellen werde. Es handelt sich um eine Anwendung zur Unterstützung der Vorbereitung auf die IHK-Abschlussprüfung.

Damit ich bei dieser kleinen Programmieraufgabe auch selbst etwas lerne, habe ich mir vorgenommen, die Unit-Tests mit JUnit 5 umzusetzen. Die neue Version des Frameworks ändert einige Annotationen und Assertions und stellt viele coole neue Features bereit, die ich unbedingt einmal ausprobieren wollte.

Sehr hilfreich dabei war das „Cheat Sheet“ von ZeroTurnaround: JUnit Cheat Sheet | zeroturnaround.com (Link: https://zeroturnaround.com/rebellabs/junit-cheat-sheet/). Aber auch der User Guide direkt auf der Website von JUnit war eine gute Unterstützung bei der Einarbeitung: JUnit 5 User Guide (Link: http://junit.org/junit5/docs/current/user-guide/).

Inzwischen habe ich alle Unit-Tests auf JUnit 5 umgestellt und bis auf die etwas längere Einarbeitungszeit für die lauffähige Einbindung des Frameworks in Gradle und Eclipse, muss ich sagen, dass mir die neuen Tests sehr gut gefallen. Insbesondere die Möglichkeit, den Tests mittels @DisplayName sprechende Namen zu geben, inklusive Leerzeichen, Umlauten usw., finde ich sehr hilfreich. Auch Methoden wie assertAll(), die mehrere Assertions hintereinander durchführt und alle aufgetretenen Fehler liefert anstatt nur den ersten, finde ich sehr spannend. Und dass (teure) Messages jetzt auch lazy erzeugt werden können, ist auch eine nette Geschichte.

Ich kann allen Java-Entwicklern nur empfehlen, sich mit JUnit 5 auseinanderzusetzen, denn es wird sicherlich der neue Standard werden.

Welche Frameworks benutzt du für deine Unit-Tests? Setzt du auf JUnit? Wenn ja, welche Version hast du im Einsatz?

Einen Monat auf der Konsole

Ein Leben ohne grafische Oberfläche

Veröffentlicht am 16.12.2016

Gerade zu Beginn der Ausbildung „zwinge“ ich meine Azubis ab und an, auf die Arbeit mit der Maus zu verzichten und stattdessen ausschließlich die Microsoft Natural Ergonomic Keyboard 4000 (Affiliate)* zu benutzen. Davon abgesehen, dass die Arbeit mit der Tastatur Ergonomie am Arbeitsplatz – Anwendungsentwickler-Podcast #60 ist, ist man – nach ein wenig Training – auch deutlich schneller unterwegs. Gerade die zentralen Entwickler-Werkzeuge – z.B. die IDE oder Git – lassen sich äußerst gut per Tastatur steuern.

Dass man aber immer noch einen Schritt weiter gehen kann, zeigt Bryan Lunduke in dieser Artikelreihe: 30 days in a terminal: Day 0 — The adventure begins | Network World (Link: http://www.networkworld.com/article/3083268/linux/30-days-in-a-terminal-day-0-the-adventure-begins.html). Er versuchte, 30 Tage lang nur auf der Konsole zu arbeiten und jede grafische Oberfläche zu meiden. Ein spannender Versuch!

Allerdings kommt der Spoiler gleich dazu: er hat es nicht durchgehalten. 30 days in a terminal: Day 10 — The experiment is over | Network World (Link: http://www.networkworld.com/article/3090404/linux/30-days-in-a-terminal-day-10-the-experiment-is-over.html) brach Bryan den Versuch ab, weil es einfach zu schmerzhaft war. Wie soll man auch ohne YouTube-Videos über den Alltag kommen!? 😉 Interessant finde ich allerdings seine Aussage, dass man z.B. Twitter sehr gut per Kommandozeile nutzen kann, da es sogar mehrere verschiedene Clients dafür gibt. Wenn man sich also einmal intensiv damit beschäftigt, kann man wohl viele tägliche Aufgaben per Kommandozeile lösen.

Was hältst du von diesem Experiment? Welche Aufgaben erledigst du grundsätzlich auf der Kommandozeile? Und wofür bevorzugst du eine grafische Oberfläche?

Entwurfsmuster für die Funktionale Programmierung

Design Pattern für die funktionale Programmierung

Veröffentlicht am 02.12.2016

Die Website von Home | F# for fun and profit (Link: http://fsharpforfunandprofit.com/) habe ich früher schon empfohlen. Und dieses Video eines seiner Vorträge reiht sich in die Liste sehr interessanter Ressourcen zur funktionalen Programmierung ein: Functional programming design patterns by Scott Wlaschin on Vimeo (Link: https://vimeo.com/113588389).

Scott erklärt darin (im Schnelldurchlauf) viele Begriffe, die man – auch als Nicht-FPler – heutzutage einfach mal gehört haben sollte: Funktor (Mathematik) – Wikipedia (Link: https://de.wikipedia.org/wiki/Funktor_(Mathematik)), Monoid – Wikipedia (Link: https://de.wikipedia.org/wiki/Monoid), Monade (Informatik) – Wikipedia (Link: https://de.wikipedia.org/wiki/Monade_(Informatik)). Und vielleicht sollte man sie sogar verstehen 😉

Wenn du jetzt aber einen trockenen mathematischen Vortrag erwartest, wirst du enttäuscht. Denn Scott Wlaschin hat sich zum Ziel gesetzt, die funktionale Programmierung aus dem Elfenbeinturm heraus in die Welt der „normalen“ Programmierer zu bringen. Das Video ist mit vielen witzigen Seitenhieben gespickt und sehr gut verständlich. Auch wenn teilweise abstrakte Konzepte behandelt werden. Es zeigt viele Konzepte der funktionalen Programmierung und warum sie so mächtig sind.

Einen kurzen Teil seines Vortrags widmet Scott auch seiner Idee des Railway Oriented Programming, bei der ich mich für JavaLand 2017 (Link: https://www.javaland.eu/konferenz/konferenzplaner/konferenzplaner.php?id=522447) auf der Java Land 2017 (Link: http://www.javaland.eu/de/home/) bedient habe.

Wie man einen echen Software-Entwickler erkennt

Wie man einen richtigen Software-Entwickler erkennt

Veröffentlicht am 25.11.2016

In meiner Vorlesung zum Thema Software-Engineering gehe ich auf die Unterschiede zwischen Programmierern und Software-Entwicklern ein. Meiner Meinung nach ist ein Software-Entwickler ein Programmierer, der sich neben dem reinen Coden auch um übergreifende Themen wie Modellierung, Testen und gutes Softwaredesign kümmert. Wie gut, dass man all das in der Ausbildung zum Anwendungsentwickler lernt! 😉

Über die Definition kann man sicherlich streiten, aber in diesem Artikel geht Jason Gorman in eine ähnliche Richtung, um einen Software-Entwickler zu erkennen: How Do I Know a „Software Developer“ When I See One? – Software People Inspiring (Link: http://codemanship.co.uk/parlezuml/blog/?postid=1407) Demnach ist man erst dann ein „echter“ Softwareentwickler, wenn man mindestens jeweils 2 verschiedene dieser Dinge beherrscht:

  1. Entwicklungsprozesse
  2. Programmiersprachen
  3. Technologie-Stacks
  4. Versionsverwaltungssysteme
  5. Build-Werkzeuge
  6. visuelle Modellierungswerkzeuge
  7. Datenbanken
  8. Testvorgehen
  9. Rollen
  10. Domänen

Wenn ich die Liste mal so für mich durchgehe, kann ich glücklicherweise überall einen Haken machen. Also bin ich wohl tatsächlich ein richtiger Entwickler! 😀

  1. Wasserfall, Scrum
  2. Java, Ruby
  3. Windows, Linux
  4. Subversion, Git
  5. Rake, Gradle
  6. ERM, UML
  7. Oracle, MySQL
  8. Unit-Tests, Oberflächentests
  9. Entwickler, Architekt
  10. Versicherung, Soziale Netzwerke

Welche Punkte „fehlen“ dir noch von der Liste? Findest du sie alle sinnvoll oder hast du noch Kriterien zu ergänzen?

Kommentare

  • Von dinora am 27.11.2016
    1.Wasserfall, Scrum 2. Java, JavaScript 3. Windows 4. SVN 5. Maven, Jenkins 6. UML, ERD 7. MySQL 8. Selenium, JUnit 9. Programmierer, Tester 10. Automobilbranche, Sportboote Ich stehe am Ende meiner Ausbildung, würde aber nicht behaupten, diese Sachen wirklich komplett zu „beherrschen“. Wenn man das mal mit einer realen Sprache vergleicht: Einen gewissen Grundwortschatz aufzubauen, geht relativ fix und einfach. Um mit der Sprache aber spielen und auch kulturelle Andeutungen / Wortspiele verstehen zu können braucht es sehr viele Jahre an Praxis. „Ich kann xyz“ hat bei mir eine komplett andere Bedeutung, als bei meinem Ausbilder. Ich war vor kurzem auf einer Konferenz (mit vielen, die ich als „alte Hasen“ bezeichnet hätte). In einem Vortrag bat der Referent einen „erfahrenen Entwickler“ nach vorn. Keiner stand auf. Deswegen würde ich auch nicht fragen „Welche Technologien kannst du?“, sondern „Was hast du mit Technologie xyz schon gemacht?“

  • Von Stefan Macke am 27.11.2016
    Hallo dinora,

    natürlich sollte man die Liste nicht allzu ernst nehmen. Ich würde mich auch nicht als „Experten“ bezeichnen. Von daher finde ich deine Idee mit dem Hinterfragen der Technologien sehr gut. Viele Bewerber schreiben eine Programmiersprache schon in ihren Lebenslauf, wenn sie irgendwann einmal eine Zeile korrigiert haben. Das ist natürlich nicht die Erfahrung, die hier gemeint ist 😉

    Viele Grüße! Stefan

Einführung in property-based testing

Einführung in property-based testing

Veröffentlicht am 18.11.2016

Kennst du schon das Property testing – Wikipedia (Link: https://en.wikipedia.org/wiki/Property_testing)? Ich bin zur Zeit völlig überwältigt von der Idee, den Input von Unit-Tests zufällig generieren zu lassen und nicht jeden fitzeligen Testfall selbst zu bauen. Oft sind Unit-Tests ja nichts weiter als eine riesige Ansammlung von möglichen Eingabekombinationen. Und der Entwickler kann nur hoffen, dass er jede Äquivalenzklasse – Wiktionary (Link: https://de.wiktionary.org/wiki/%C3%84quivalenzklasse) erwischt hat.

Scott Wlaschin gibt in diesem sehr empfehlenswerten Artikel eine Einführung in die Idee des property-based testing: Commentary on ‚Roman Numerals Kata with Commentary‘ | F# for fun and profit (Link: http://fsharpforfunandprofit.com/posts/roman-numeral-kata/). Anhand des Beispiels der Coding Dojo Wiki: KataRomanNumerals (Link: http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals) erklärt er die Vorteile des Tests von allgemeinen Eigenschaften der Ausgabewerte der zu testenden Funktion anstatt alle erdenklichen Kombinationen von Ein- und Ausgabewerten selbst aufzuschreiben. Das Framework – im Beispiel FsCheck (Link: https://fscheck.github.io/FsCheck/) für F# – generiert einen Haufen unterschiedlicher Input-Werte, die alle eine gewisse Eigenschaft haben, z.B. „positive ganze Zahl“. Und die Ausgabewerte der zu testenden Funktion werden dann auf eine festgelegte Eigenschaft geprüft, z.B. „gerade ganze Zahl“.

Das Finden der Testfälle ist vielleicht etwas weniger intuitiv, weil der Entwickler sich Gedanken über die allgemeinen Eigenschaften seiner Funktionen machen muss und nicht einfach nur Einzelfälle testen kann. Aber letztlich testen diese Eigenschaften natürlich deutlich umfassender die Funktionalität des Systems als einzelne ausgewählte Testfälle. Und die Sicherheit, nichts übersehen zu haben, ist auch deutlich höher.

Hast du schon einmal property-based testing angewendet? Wenn ja, welche Frameworks (und welche Sprache) nutzt du dafür?

Paranoide Programmiertechniken

Paranoide Programmiertechniken

Veröffentlicht am 11.11.2016

Hin und wieder stoße ich beim Review von Code auf kleine seltsame Fragmente, die anders aussehen, als man sie vielleicht erwarten würde. Ein Beispiel ist "der String".equals(str) anstatt str.equals("der String") oder 42 == number anstatt number == 42. Doch viele davon haben einen durchaus sinnvollen Hintergrund. So verhindert das erste Beispiel eine NullPointerException, wenn str null ist. Und das zweite sorgt für einen Compilerfehler, falls man das zweite = vergisst und anstelle des Vergleichs aus Versehen eine Zuweisung programmiert.

Lukas Eder hat in diesem Artikel bei den Java Code Geeks ein paar solcher „paranoiden“ Techniken in Java zusammengefasst: Top 10 Useful, Yet Paranoid Java Programming Techniques | Java Code Geeks – 2016 (Link: https://www.javacodegeeks.com/2015/08/top-10-useful-yet-paranoid-java-programming-techniques.html). Viele lassen sich allerdings auch direkt auf beliebige andere Sprachen übertragen.

Ich finde tatsächlich alle vorgestellten Ideen sinnvoll und habe viele schon selbst verwendet. Und wenn man ein wenig Erfahrung mit der Programmierung gesammelt hat, kann man den Sinn dahinter auch gut nachvollziehen, vielleicht weil man selbst schon einmal unnötig Zeit mit der Fehlersuche verbracht hat, die bei Einsatz der Beispiele nicht angefallen wäre.

Nutzt du einige der vorgestellten Techniken, um deinen Code weniger fehleranfällig zu machen? Hast du noch weitere Beispiele für „paranoide“ Codefragmente?

Kommentare

  • Von Christian am 16.11.2016
    Schreibfehler: Arikel
  • Von Stefan Macke am 16.11.2016
    Ist korrigiert. Danke!

Anti-Pattern im Vim

Anti-Pattern im Vim

Veröffentlicht am 04.11.2016

Seit Jahren nutze ich den Vim (Link: http://www.vim.org/). Ich würde ihn sogar als meinen Lieblingseditor bezeichnen. Es ist immer wieder erstaunlich, wie produktiv man mit diesem Texteditor arbeiten kann – wenn man ihn beherrscht. Doch genau das ist nicht gerade einfach. Zumindest für Einsteiger.

Jedes Jahr sehe ich wieder bei meinen neuen Studierenden, wie sie sich mit dem Vim auf der Linux-Konsole herumplagen. Die meisten wechseln nach ein paar gescheiterten Versuchen zum nano (Link: https://www.nano-editor.org/), weil er ja viel einfacher zu bedienen ist. Dazu passt dieser nette Tweet, den ich auch gerne in Präsentationen verwende:

Ich gebe zu, dass der Vim nicht gerade intuitiv bedienbar ist. Es gibt sogar ein kleines Browser-Spiel, nur um die Basis-Befehle zu lernen: VIM Adventures (Link: http://vim-adventures.com/). Aber die investierte Zeit ist es wert, da man sie später durch deutlich weniger Tastendrücke vielfach wieder reinholt. Sofern man ein paar Anfängerfehler vermeidet. Tom Ryder listet in diesem Artikel einige Anti-Pattern bei der Benutzung des Vim auf: Vim anti-patterns (Link: https://sanctum.geek.nz/arabesque/vim-anti-patterns/). Darunter Klassiker wie das zeilenweise Bewegen des Cursors z.B. mit jjjjjjjjj oder die Benutzung der Cursor-Tasten zur Navigation.

Ich bin immer wieder fasziniert darüber, wenn meine Studierenden sich über den Vim aufregen, aber auf ihrem Betriebssystem noch nicht einmal einen vernünftigen Texteditor installiert haben. Die meisten haben noch nie etwas von Editoren wie Notepad++ (Link: https://notepad-plus-plus.org/) oder PSPad (Link: http://www.pspad.com/de/) gehört. Ich frage mich dann immer, wie sie das so lange ausgehalten haben. Ich glaube es gibt kein Tool, das ich häufiger bei der täglichen Arbeit nutze, als meinen Texteditor. Er ist für mich das „schweizer Taschenmesser“ des ITlers. Daher kann ich nur jedem Azubi empfehlen, sich einen vernünftigen Texteditor (=alles außer Notepad) zu suchen und seine Benutzung zu lernen.

Für einen richtig tiefen Einstieg in Vim empfehle ich – wie immer – Drew Neil – Practical Vim, Second Edition: Edit Text at the Speed of Thought (Affiliate)* von Drew Neil. Wahnsinn, was man aus diesem alten Editor alles rausholen kann!

Drew Neil - Practical Vim, Second Edition: Edit Text at the Speed of Thought (Affiliate)*

Kommentare

  • Von Manuel (Link: http://manulicious.de/) am 04.11.2016
    Für einen guten Einstieg kann man sonst auch gerne einfach mal vimtutor in der Kommandozeile starten 😉

  • Von Stefan Macke am 05.11.2016
    Hallo Manuel,

    ja klar! Manchmal vergesse ich die einfachsten Sachen 🙂 Danke für den Hinweis.

    Viele Grüße! Stefan

  • Von max am 20.11.2016
    Obwohl ich seit Jahren ausschließlich mit Vim arbeite, kann ich plattformübergreifend dennoch Geany (https://www.geany.org/) empfehlen. Es handelt sich eher um eine Mini-IDE mit Features wie Regex-Suche, einer integrierten Konsole wie bei Neovim und etwas, das wir Vimmer „Tagbar“ und NERDTree nennen würden. Außerdem gibt es Plugins und der Editor kann out of the Box, wofür ich YouCompleteMe erst kompilieren musste: Also Vervollständigen (wobei da YCM etwas besser ist, wenn es dann einmal funktioniert) Vielen Dank für diese Webseite und die Beiträge!

  • Von Stefan Macke am 21.11.2016
    Hallo max,

    danke für den Tipp. Geany kannte ich noch nicht. Sieht ja ganz interessant aus das Tool! Die Installation von Plugins usw. im Vim finde ich auch immer nervig. Warum gibt es nicht einfach einen perfekten Editor, der alles direkt so macht, wie ich es will? 😀

    Viele Grüße! Stefan

Rangliste der populärsten Datenbanken

Rangliste der populärsten Datenbanken

Veröffentlicht am 28.10.2016

Dass es eine „Bestenliste“ der Programmiersprachen gibt, wusste ich schon – den TIOBE Index | TIOBE – The Software Quality Company (Link: http://www.tiobe.com/tiobe-index/) schaue ich mir regelmäßig an. Auf dem Java Forum Nord 2016 (Link: http://javaforumnord.de/site/2016/) habe ich Databases — the choice is yours // Speaker Deck (Link: https://speakerdeck.com/xeraa/databases-the-choice-is-yours) allerdings zum ersten Mal von einem entsprechenden Ranking für Datenbanken erfahren: DB-Engines Ranking – die Rangliste der populärsten Datenbankmanagementsysteme (Link: http://db-engines.com/de/ranking).

Mit Oracle an der Spitze hätte ich aus dem Bauch heraus gerechnet, aber dass direkt auf Platz 2 MySQL steht und mit MongoDB bereits auf Platz 4 die erste NoSQL-Datenbank folgt, hat mich dann doch überrascht. Insgesamt befinden sich unter den ersten 10 Datenbanken schon 3 NoSQL-Datenbanken (die Philipp auch alle in seinem Talk angesprochen hat).

Man könnte also – dem Ranking zufolge – schon sagen, dass NoSQL in der Praxis angekommen und sogar schon etabliert ist. Dann kann es ja eigentlich nur noch eine Frage der Zeit sein, bis dieses Thema auch in der IHK-Prüfung abgefragt wird.

Daher wie immer mein Appell an die angehenden Prüflinge: Schaut euch nicht nur die altbekannten Themen an, sondern blickt auch einmal über den Tellerrand der Relationale Datenbanken – Häufige Fragen im Fachgespräch – Anwendungsentwickler-Podcast #17 hinweg.

Genau wie Philipp in seinem Vortrag kann ich für dieses Thema hauptsächlich ein Buch empfehlen: Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement (Affiliate)*.

Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement (Affiliate)*

Darin werden alle Konzepte aus dem NoSQL-Bereich – spaltenorientiert, Key-Value-Store, dokumentenorientiert, objektorientiert und Graphendatenbanken – anhand prominenter Beispiele sehr praxisnah erklärt.

Setzt du NoSQL in deinen Projekten ein? Welche Use-Cases bildest du damit ab? Welche Vor- und Nachteile hast du vielleicht erkannt?

Lizenzen verständlich erklärt

Lizenzen und Nutzungsbedingungen verständlich erklärt

Veröffentlicht am 21.10.2016

Musstest du schon einmal einen langen rechtlichen Text – z.B. eine Lizenz- oder Nutzungsvereinbarung – lesen und hattest Schwierigkeiten, ihn zu verstehen? Wenn ja, kann ich dir die folgende Website empfehlen, auf die mich Markus Amshove (Link: https://amshove.org) aufmerksam gemacht hat: TLDRLegal – Software Licenses Explained in Plain English (Link: https://tldrlegal.com/). Auf der Seite werden die – meist sehr langen und schwer verständlichen – Lizenzen u.a. aus dem Open-Source-Umfeld kurz und knapp (daher TLDR -> too long, didn’t read) erläutert.

Ich habe mir direkt mal die YouTube Terms of Service Explained in Plain English – TLDRLegal (Link: https://tldrlegal.com/license/youtube-terms-of-service) angeschaut. Aber auch häufig missverstandene Lizenzen wie die GNU General Public License v3 (GPL-3) Explained in Plain English – TLDRLegal (Link: https://tldrlegal.com/license/gnu-general-public-license-v3-(gpl-3)) oder Creative Commons Attribution 4.0 International (CC BY 4.0) Explained in Plain English – TLDRLegal (Link: https://tldrlegal.com/license/creative-commons-attribution-4.0-international-(cc-by-4)) werden anschaulich – sogar mit einer netten grafischen Gegenüberstellung der Cans und Cannots – dargestellt.

Ich kann die Seite nur jedem Entwickler da draußen empfehlen! Meist wissen die internen Rechtsabteilungen in Unternehen weniger über die Lizenzen als die Entwickler. Und gerade bei wichtigen Entscheidungen – z.B. für oder gegen den Einsatz einer Open-Source-Library in eigenen Produkten – kann die Website eine Unterstützung bieten.

Für die Wahl der passenden Lizenz für die eigenen Inhalte kann ich darüber hinaus auch noch Choose an open source license – Choose a License (Link: http://choosealicense.com/) empfehlen. Hier werden übersichtlich die wichtigsten Lizenzen gegenübergestellt.

Musstest du schon einmal eine Lizenz für ein Produkt auswählen? Wie hast du die Entscheidung getroffen?

Kommentare

  • Von Robin Schneider am 22.10.2016
    Hallo Stefan, https://tldrlegal.com/ ist ein sehr guter Tipp. Ich hatte die Seite bisher nur für Software Lizenzen genutzt. Das auch AGBs usw. zusammengefasst sind ist sehr praktisch 🙂 Die Wahl einer Lizenz für eine Software oder Produkt ist für mich eine Abwägung zwischen Copyleft (Link: https://de.wikipedia.org/wiki/Copyleft) und dem Vermeiden, dass Software Entwickler doppelte Arbeit machen müssen. Ich würde am liebsten alles unter eine AGPL-3.0 (Link: https://tldrlegal.com/license/gnu-affero-general-public-license-v3-%28agpl-3.0%29) stellen. Das hätte allerdings die Einschränkung, dass diese Software nur in (A)GPL-3.0 lizenzierten Projekten verwendet/gelinkt werden darf, was wiederum Vor- und Nachteile hat. Der Punkt keine doppelte Arbeit für Entwickler finde ich ebenfalls relativ wichtig, da ich es Sinnlos finde, wenn ein Entwickler etwas das ein zweites Mal implementieren muss, nur weil eine Bibliothek nicht veröffentlicht und lizenziert ist. In der Zeit könnte der zweite Entwickler entweder die erste Implementierung besser machen oder etwas anderes Produktives. Für eine JavaScript Bibliothek für die Auswertung von Öffnungszeiten (opening_hours.js (Link: https://github.com/opening-hours/opening_hours.js)) habe ich eine solche Abwägung getroffen und LGPL-3.0 (Link: https://tldrlegal.com/license/gnu-lesser-general-public-license-v3-%28lgpl-3%29) gewählt um die Verwendung auch in nicht GPL lizenzierten Projekten zu erlauben. Da verfolge ich mehr den Gedanken eine Bibliothek für alles (zukünftig auch mehrere Programmiersprachen (Link: https://github.com/opening-hours/opening_hours.js/issues/136)). Wenn ich Skripte/Module schreibe, die ich nur für Benutzung in anderen GPL lizenzierten Projekten vorsehe, dann gibt es die AGPL-3.0 (aktuelles Beispiel: yaml4rst (Link: https://github.com/ypid/yaml4rst)) 🙂 Wenn ich an anderer kommerzieller Software Erweiterung/Workarounds vornehme greife ich eventuell sogar zu einer BSD Lizenz (hipchat_private_chat_delete (Link: https://github.com/hamcos/helper-scripts/tree/master/hipchat_private_chat_delete)), mit dem Hintergrund, dass die Funktion möglichst schnell offiziell in das Produkt aufgenommen werden kann und mit dem Wissen, dass wenn ich es unter GPL stellen würde, es wohl leider entweder neu geschrieben oder einfach übernommen wird ohne der GPL zu entsprechen. Das halte ich beruflich und privat fast identisch wobei ich beim privaten Programmieren noch etwas mehr daran interessiert bin, dass sich kein Anderer das Programmierte schnappt und es in einem kommerziellen Produkt einsetzt/weiterentwickelt ohne den Copyleft Gedanken. Verkaufen von GPL lizenzierter Software durch Andere ist für mich akzeptabel, dann aber unter den entsprechenden Lizenzbedingungen. Beruflich ist der Kunde und das eigene Unternehmen natürlich in die Entscheidung mit einbezogen wobei es so ist, wie du auch schon gesagt hast, dass sich die Entwickler meist mehr mit Lizenzen auskennen, als Andere. Gruß Robin

  • Von Stefan Macke am 23.10.2016
    Hallo Robin,

    ich mache es im Prinzip genau wie du. LGPL für Module, die von anderen weiterentwickelt werden sollen/können und teilweise sogar die MIT License – Choose a License (Link: http://choosealicense.com/licenses/mit/), die kurz gesagt einfach alles erlaubt – außer verklagt zu werden 😉

    Viele Grüße! Stefan

  • Von Robin Schneider am 27.10.2016
    Hallo Stefan, für Nutzungsbedingungen bin ich gerade auf https://tosdr.org/ gestoßen. Hier werden die Nutzungsbedingungen gleich noch bewertet (Link: https://tosdr.org/classification.html) und es gibt ein Browser Plugin, welches in der Adressleiste eine einfache Bewertung anzeigt. Lohnt sich also, wenn man ab und zu mal auf https://www.privacytools.io/ und co vorbeischaut 🙂 Gruß Robin

  • Von Stefan Macke am 27.10.2016
    Haha 🙂 Klasse! Danke für den Tipp!

Tipps zum Refactoring

Tipps zum Refactoring

Veröffentlicht am 14.10.2016

Ich mag Refactoring. Besonders gut gefällt mir diese Definition, mit der ich auch immer meine Studierenden quäle:

Semantikinvariante Modifikation von Quelltext.

Leider finde ich die Quelle nicht wieder (und Google-Suche: Semantikinvariante Modifikation von Quelltext (Link: https://www.google.de/search?q=Semantikinvariante+Modifikation+von+Quelltext) 😀 ).

Refactoring ist auch der dritte und letzte Schritt im TDD nach Kent Beck (Link: https://de.wikipedia.org/wiki/Testgetriebene_Entwicklung#TDD_nach_Kent_Beck), was die Wichtigkeit noch einmal unterstreicht. Daher behandelt mein Link der Woche dieses Thema.

Michael Lumpp gibt in diesem Artikel einige Tipps zum Refactoring: Tips for Refactoring your Code – Karbyn Blog (Link: http://blog.karbyn.com/articles/tips-for-refactoring-your-code/?imm_mid=%E2%80%A6). Gerade für Einsteiger ist nicht immer klar, wann und wie refaktorisiert werden sollte. Michaels erste Regel ist daher: „Get it working!“. Erst danach geht es dann um das WAS und das WANN.

Diesem Tipp würde ich mich direkt anschließen. Zunächst einmal lösen wir das gestellte Problem. Und wenn alles läuft und die Tests grün sind, fangen wir mit dem Refactoring an. Refactoring ist kein Selbstzweck, sondern soll Code lesbarer und verständlicher machen. Manchmal aber auch schneller oder weniger ressourcenfressend.

Wenn du das Thema Refactoring vertiefen willst, gibt es eigentlich nur ein Buch, das ich empfehlen kann: Martin Fowler – Refactoring: Improving the Design of Existing Code (Affiliate)* von Martin Fowler. Das Ding ist zwar schon von 1999, hat aber keinesfalls an Relevanz verloren. Es gilt immer noch als das Standardwerk zum Refactoring. Eine absolute Leseempfehlung für jede/n Softwareentwickler/in!

Martin Fowler - Refactoring: Improving the Design of Existing Code (Affiliate)*

Weche Refactorings nutzt du regelmäßig bei der Arbeit? Hast du sie dir selbst beigebracht oder empfehlenswerte Literatur genutzt? Ich freue mich über deinen Kommentar!

Kommentare

  • Von Anna (Link: http://www.klebefolien-shop.eu) am 20.10.2016
    Vielen dank für die Informationen und die ausführliche Erklärung. Denke das der Artikel ziemlich hilfreich sein wird. Gruß Anna
  • Von Stefan Macke am 21.10.2016
    Gern geschehen! 🙂

Zeit finden, um ein besserer Programmierer zu werden

Zeit finden, um ein besserer Programmierer zu werden

Veröffentlicht am 07.10.2016

Als Softwareentwickler/-in hat man häufig das Gefühl, ständig hinterherzuhinken und zu wenig zu lernen. Zumindest, wenn man sich ernsthaft mit seinem Beruf auseinandersetzt. Es gibt so viele Programmiersprachen, Frameworks und Technologien da draußen, dass es schwierig ist, einen Überblick zu behalten und einschätzen zu können, welche Dinge man lernen sollte.

Bill Sourour gibt in diesem Artikel einige Tipps, um die nötige Zeit zum Lernen zu finden: Finding Time to Become a Better Developer – Free Code Camp (Link: https://medium.freecodecamp.com/finding-time-to-become-a-better-developer-eebc154881b2#.wcmlzn6ip). Es handelt sich allerdings nicht um einen klassischen Artikel zum Thema Zeitmanagement, sondern um eine Liste mit interessanten Aussagen zur Arbeit von uns Softwareentwicklern. Der erste Punkt ist auch gleich – meiner Meinung nach – der wichtigste: Du musst nicht alles, das neu ist, lernen, um am Ball zu bleiben. Schön fand ich dieses Zitat:

The old thing is dead. Long live the NEW, about-to-be-old thing!

Das sagt eigentlich alles. Gerade im Bereich der Webentwicklung jagt ein neues Framework das nächste und sogar AngularJS 2.0 Is Radically Different (Link: http://www.i-programmer.info/news/167-javascript/7932-angularjs-20-is-radically-different-.html) der gleichen Frameworks erfordern manchmal eine komplette Überarbeitung des eigenen Codes. Das ist schon fast lächerlich…

Ich finde Bills Fokus auf das Wesentliche – Methoden wie TDD oder das Erlernen von Grundlagen – sehr sinnvoll und konnte einige Anregungen aus dem Artikel mitnehmen. Gerade auch Punkt 3 – „Working 24/7 does NOT make you a hero.“ – sollte ich mir selbst mal zu Herzen nehmen! 😉

Wie stellst du sicher, dass deine Kenntnisse und Fähigkeiten up-to-date bleiben und du nicht den Anschluss verlierst?

Funktoren und Monaden

Einführung in Funktoren und Monaden

Veröffentlicht am 30.09.2016

Seit es funktionale Sprachkonstrukte auch in Mainstream-Sprachen wie Java und C# geschafft haben, wird es immer wichtiger für Entwickler, sich mit den Ideen der funktionalen Programmierung auseinanderzusetzen. Tomasz Nurkiewicz beschreibt in diesem gut verständlichen Artikel zwei wichtige Konzepte: Functor and monad examples in plain Java | Java Code Geeks – 2016 (Link: https://www.javacodegeeks.com/2016/06/functor-monad-examples-plain-java.html).

Ohne es zu wissen, hast du vielleicht sogar schon beide Konstrukte genutzt. Die Processing Data with Java SE 8 Streams, Part 1 (Link: http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html) in Java 8 oder Introduction to LINQ Queries (C#) (Link: https://msdn.microsoft.com/de-de/library/bb397906.aspx) in C# basieren letzlich auf Funktoren und Monaden bzw. nutzen sie. Der obige Artikel erklärt anhand einfacher Beispiele in Java die Funktionalität beider Konzepte und zeigt auch ihre Vor- und Nachteile auf. Zum Verständnis solltest du dich allerdings bereits mit Generischer Typ – Wikipedia (Link: https://de.wikipedia.org/wiki/Generischer_Typ) auskennen (ein Thema, das auch immer wieder im Fachgespräch angesprochen wird).

Ich finde den Artikel sehr gut verständlich. Er erklärt die Konzepte nicht mit grauer Theorie (und davon gibt es im Umfeld der funktionalen Programmierung mehr als genug), sondern mit konkreten Beispielen, die mit ein paar Zeilen Code umgesetzt werden können.

Wenn dich die Konzepte der funktionalen Programmierung interessieren und du noch mehr darüber lernen willst, kann ich Venkat Subramaniam – Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions (Affiliate)* empfehlen. Venkat Subramaniam erklärt darin die wichtigsten Ideen der funktionalen Programmierung und gibt viele Praxisbeispiele für die Umsetzung in Java 8.

Venkat Subramaniam - Functional Programming in Java: Harnessing the Power of Java 8 Lambda Expressions (Affiliate)*

Setzt du funktionale Sprachkonstrukte bei deiner täglichen Arbeit ein? Findest du sie eher hilfreich oder überflüssig?

Bitte nicht unterbrechen!

Warum man Programmierer nicht unterbrechen sollte

Veröffentlicht am 23.09.2016

Dieses kurze Comic zeigt sehr schön, warum man Programmierer nicht bei der Arbeit unterbrechen sollte: This Is Why You Shouldn’t Interrupt a Programmer – The Slightly Disgruntled Scientist (Link: http://heeris.id.au/2013/this-is-why-you-shouldnt-interrupt-a-programmer/). Selbst nach winzigen Unterbrechungen ist die Zeit, bis man wieder produktiv weiter am Problem arbeiten kann, sehr lang. Einige Studien gehen von bis zu 30 Minuten aus: And it’s gone —The true cost of interruptions – JAXenter (Link: https://jaxenter.com/aaaand-gone-true-cost-interruptions-128741.html).

Deswegen sollte man dafür sorgen, dass Softwareentwickler im Arbeitsalltag lange Phasen ungestörter Arbeit haben. Das hat auch nichts mit sozialen Ängsten oder dem Klischee des eigenbrödlerischen Programmierers zu tun. Die Arbeit, die Entwickler verrichten, erfordert es einfach, sich konzentriert und tiefergehend mit gestellten Problemen auseinanderzusetzen.

In der Praxis sieht das aber häufig ganz anders aus, was vielleicht auch daran liegt, dass Führungspersonen einen ganz anderen Arbeitsrhythmus haben. Paul Graham unterscheidet in diesem Artikel zwei Arten von Tagesabläufen: Maker’s Schedule, Manager’s Schedule (Link: http://www.paulgraham.com/makersschedule.html). Die Aufgaben eines Entwicklers benötigen demzufolge längere Phasen ungestörter, konzentrierter Arbeitszeit, während Manager ständig von einem Meeting zum anderen hetzen und zwischen verschiedenen Aufgaben hin- und herspringen müssen.

Falls du auch hin und wieder mal bei der Arbeit gestört wirst, findest du in diesem Artikel einige kleine Hilfen, die Entwicklern nach Unterbrechungen den Wiedereinstieg in die Programmierung erleichtern (z.B. einfache TODO-Tags): Gamasutra – Programmer, Interrupted (Link: http://www.gamasutra.com/view/feature/190891/programmer_interrupted.php).

Und ein sehr gutes Buch zum Thema kann ich auch noch empfehlen. Es ist auch gerade erst bei Audible als Hörbuch erschienen und ich habe es begeistert gelesen (bzw. gehört 😉 ). Im Rahmen des Amazon.de: Audible Hörbücher Probemonat (Affiliate) (Link: https://f.macke.it/Audible)* kannst du dir das Buch direkt herunterladen.

Deep Work: Rules for Focused Success in a Distracted World von Cal Newport bei Amazon (Affiliate)*

Wie verhinderst du Störungen bei der Programmierung? Bzw. wie gehst du mit ihnen um? Habt ihr vielleicht Regeln im Büro, wie den „Talk-Free-Thursday“?

Kommentare

  • Von Manuel (Link: http://manulicious.de) am 16.10.2016
    Ich habe mir Noise-Cancelling-Kopfhörer gekauft, die erstmal Umgebungsgeräusche (Straße, Umbauarbeiten, usw.) herausfiltern, da ich extrem anfällig für Ablenkung durch akustische Reize bin. Dazu versuche ich meine Kollegen darauf zu konditionieren, mich in Ruhe zu lassen, wenn ich die Dinger auf habe und nicht auf sie reagiere. Das ist gar nicht so einfach wie es sich anhört—viele fangen dann erst recht an zu rufen, winken oder mich anzustupsen. Manche merken und respektieren aber auch, dass ich versuche, sie zu ignorieren. Ich habe tatsächlich einen albernen Zettel an die Wand gehängt mit der Aufschrift „Please respect headphones as a sign of intentional isolation“—wiegesagt mit eher mittelmäßigem Erfolg.

  • Von Stefan Macke am 16.10.2016
    Solche Kopfhörer wollte ich auch immer schonmal ausprobieren! Habe schon viel darüber gehört. Aktuell habe ich ein paar günstigere, die nur die Umgebung etwas dämpfen, aber sie nicht aktiv ausblenden.

    Aber für die Arbeit wäre das bei mir nichts. Dann können meine Azubis mich ja gar nichts mehr fragen 😉

    Im Büro muss man sich einfach abstimmen und alle müssen mitmachen. Wenn sich Kollegen natürlich nicht so leicht gestört fühlen oder das Problem der Unterbrechungen nicht kennen, wird es schwierig. Vielleicht kannst du ja in einem „Lunch-and-Learn“ über die Probleme aufklären. Die passenden Zahlen habe ich ja oben verlinkt 🙂

Together we make IT

Podcast-Empfehlung: Together we make IT

Veröffentlicht am 16.09.2016

Ich bin ständig auf der Suche nach guten neuen Podcasts und habe aktuell einen empfehlenswerten Podcast für IT-Azubis gefunden: Together we make IT (Link: http://podcast.together-we-make.it/) von Timo Schlappinger. Die ca. 20 Minuten langen Episoden sind gut verständlich und behandeln grundsätzliche Themen der IT.

Obwohl mir persönlich die Inhalte bereits bekannt sind, höre ich als kleine Auffrischung zwischendurch immer wieder rein und kann den Podcast gerade „frischen“ Azubis empfehlen, die viele Grundlagen noch lernen müssen. Hier mal eine Auswahl an interessanten Episoden, die auch prüfungsrelevantes Wissen enthalten:

  • Wie funktioniert ein Netzwerk= (Link: http://podcast.together-we-make.it/episode017/)
    • Gute Grundlagenfolge mit IP-Adressen, privaten IP-Netzwerkbereichen usw.
  • Welche Medien eignen sich zur Datensicherung? (Link: http://podcast.together-we-make.it/episode013/)
    • Die Vor- und Nachteile einzelner Speichermedien wurden bereits in IHK-Prüfungen abgefragt. Und auch der absolut prüfungsrelevante Bereich RAID wird in dieser Episode angesprochen.
  • Was ist die Cloud? (Link: http://podcast.together-we-make.it/episode-002-was-ist-die-cloud/)
    • Eine schöne Einführung ins Thema u.a. mit wichtigen Begriffen wie Software as a Service (SaaS), Platform as a Service (PaaS) und Infrastructure as a Service (IaaS).

Falls du noch zu Beginn deiner Ausbildung stehst, hör doch mal bei Timo rein und gib ihm ein Feedback!

Was hältst du von Timos Podcast? Konntest du noch etwas lernen oder wusstest du schon alles? 😉

Tolle Typisierung

Tolle Typisierung

Veröffentlicht am 09.09.2016

Man kann eigentlich gar nicht genug über Typisierung sprechen, gerade wenn man die Antworten vieler Azubis auf entsprechende Fragen in den mündlichen Prüfungen kennt 😉 In diesem Artikel geht Oliver Sturm kurz auf einige zentrale Vor- und Nachteile statischer und dynamischer Typisierung im Kontext verschiedener Programmiersprachen ein: Tolle Typen – Wie statisch muss Typisierung sein? (Link: https://entwickler.de/online/windowsdeveloper/typen-wie-statisch-typisierung-246457.html)

Ich persönlich arbeite lieber in statisch typisierten Sprachen, weil die Toolunterstützung dort einfach besser ist. Codevervollständigung in dynamischen Sprachen ist sehr schwierig und auch einfachste Refactorings wie das Umbenennen von Methoden werden meist nur rudimentär unterstützt. Allerdings weiß ich die Vorteile dynamischer Sprachen durchaus zu schätzen und setze sie für kleine Probleme gerne ein, weil ein statisches Typsystem auch manchmal im Weg ist.

Meiner Meinung nach sollten Azubis im Laufe ihrer Ausbildung mindestens eine dynamische und eine statische Programmiersprache kennenlernen, einfach um die Vor- und Nachteile einschätzen zu können. Und ich erwarte heutzutage von jedem Prüfling, dass er oder sie mindestens die folgenden Begriffe erklären und mit Beispielen hinterlegen kann:

  • Static vs. Dynamic Typing (statisch/dynamisch)
  • Strong vs. Weak Typing (stark/schwach)
  • Duck Typing
  • Type Inference (Typinferenz)

Wenn du eine ausführliche Erklärung zu den Begriffen haben möchtest, schau dir doch mal mein Hörbuch zur Programmierung und Objektorientierung an: Das perfekte Fachgespräch (Link: http://dasperfektefachgespraech.de).

Welche Typisierung bevorzugst du? Wie ist deine Lieblingsprogrammiersprache typisiert?

Tabs vs. Spaces

Tabs vs. Spaces

Veröffentlicht am 02.09.2016

Kaum zu glauben, dass ich hier noch nie eine der zentralen Fragen der Programmierung angesprochen habe: Tabs oder Spaces? 😉 Daher hole ich das nun nach und empfehle dazu diesen Artikel von Alex Zhitnitsky: Tabs vs Spaces: How They Write Java at Google, Twitter, Mozilla and Pied Piper | Java Code Geeks – 2016 (Link: https://www.javacodegeeks.com/2016/07/tabs-vs-spaces-write-java-google-twitter-mozilla-pied-piper.html).

Alex geht darin nicht nur auf die Problematik von Tabs vs. Spaces ein, sondern auch noch auf ein paar weitere spannende Fragestellungen, über die Programmierer stundenlang diskutieren können. Ob diese Diskussion sinnvoll ist, lasse ich mal dahingestellt.

Im Artikel wird auch gezeigt, wie einige große Unternehmen – z.B. Google und Twitter – die Frage nach Coderichtlinien beantworten. Das kann man dann natürlich bei heißen Diskussionen über die richtige Lösung schön als Quelle anführen. 😉

Leider heißt das für mich, dass ich meine Antwort (nämlich Tabs!) wohl noch einmal überdenken sollte, da alle genannten Unternehmen auf Spaces setzen. Auf meine Klammersetzung ({ und } in separaten Zeilen) lasse ich allerdings nichts kommen!

Habt ihr in deinem Unternehmen Coderichtlinien, an die sich die Entwickler halten müssen? Welche Richtlinien findest du sinnvoll und welche nicht?

Kommentare

  • Von Robin Schneider (Link: https://github.com/ypid) am 02.09.2016
    Hallo Stefan, das überrascht mich, dass du Tabs bevorzugst. Ich bin mittlerweile auch der Meinung, dass nur Spaces beim Programmieren benutzt werden sollten (mit Ausnahme von Dateiformaten, wo diese erzeugen werden: GNU Make (Link: https://en.wikipedia.org/wiki/Make_%28software%29)). Einer der überzeugenderen Gründe ist ja, dass Tabs auf anderen Computern anders dargestellt werden können. Siehe auch Tabs versus Spaces (Link: https://www.youtube.com/watch?v=SsoOG6ZeyUI) (S03E06) aus der Serie *Silicon Valley (2014–) * (Link: http://www.imdb.com/title/tt2575988/) 😉 Den anderen Punkten aus dem verlinkten Artikel kann ich ebenfalls zustimmen. Gruß Robin

  • Von Stefan Macke am 02.09.2016
    Hi Robin,

    für mich war die freie Konfiguration der Tab-Breite immer der zentrale Vorteil. Jeder Entwickler kann sich die Einrückung selbst einstellen. Wenn er lieber 8 Leerzeichen nutzen möchte, ist das eine Konfigurationsänderung im Editor und fertig. Außerdem verbraucht ein 0x09 natürlich auch deutlich weniger Speicherplatz als vier 0x32 😉

    Viele Grüße! Stefan

Magie beim Programmieren

Magie beim Programmieren

Veröffentlicht am 26.08.2016

Als ich vor einigen Jahren das erste Mal mit Ruby on Rails gearbeitet habe, war ich erstaunt, wie wenig Code für eine lauffähige Webanwendung nötig ist. Im Gegensatz zu anderen Programmiersprachen und Frameworks schien Rails einfach „magisch“ zu funktionieren und Dinge automatisch zu tun, ohne dass ich sie als Entwickler explizit programmieren musste. Richard Schneeman geht in seinem Artikel auf diese „Magie“ beim Programmieren ein: Do You Believe in Programming Magic? – via @codeship | via @codeship (Link: http://blog.codeship.com/programming-magic/)

Er diskutiert die Vor- und Nachteile „automagischer“ Programmierung, die zwar eine hohe Produktivität bietet, aber bei der Fehlersuche durchaus hinderlich sein kann, da der Entwickler teilweise gar nicht mehr direkt nachvollziehen kann, was die Sprache bzw. das Framework eigentlich macht. Obwohl man also relativ schnell zu lauffähigen Lösungen kommt, sollte man nicht den Fehler machen, Funktionen einfach hinzunehmen oder gar nicht mehr verstehen zu wollen, was genau eigentlich passiert. Das ist ein Rat, den ich auch immer wieder allen Prüflingen gebe: Alles, was du verwendest, musst du auch erklären können.

Ein gewisser Grad an „syntactic sugar“ und automagischen Elementen ist für den Entwickler sicherlich hilfreich. Aber wenn man selbst nicht mehr versteht, was eigentlich vor sich geht, sollte man lieber einen Gang zurückschalten!

Hast du schon einmal „Magie“ beim Programmieren erlebt? Welche Beispiele fallen dir zu diesem Thema ein?

Komplexe Software testen ohne Mocks

Komplexe Software testen ohne Mocks

Veröffentlicht am 19.08.2016

Bereits vor mehreren Jahren habe ich das wirklich empfehlenswerte Buch Growing Object-Oriented Software, Guided by Tests – Amazon (Affiliate)* („GOOS“) von Steve Freeman und Nat Pryce gelesen. Eine Rezension spare ich mir hier, da ich bereits früher eine geschrieben habe (vgl. meinen damaligen Growing Object-Oriented Software, Guided by Tests (Freeman/Pryce)).

Vladimir Khorikov, den ich von seinem Pluralsight-Kurs zum Thema Domain Driven Design kenne (siehe auch meinen Artikel von letzter Woche: Einführung in Domain Driven Design), greift nun die Kernideen des Buchs in seinem Artikel Growing Object-Oriented Software, Guided by Tests Without Mocks – Enterprise Craftsmanship (Link: http://enterprisecraftsmanship.com/2016/07/05/growing-object-oriented-software-guided-by-tests-without-mocks/) wieder auf und stellt eine Lösung vor, die komplett ohne Mocks auskommt.

Der Artikel ist absolut lesenswert. Er ist sehr umfangreich und mit vielen Abbildungen und Code-Beispielen illustriert. Und noch viel wichtiger: Er zeigt, dass man auch bei komplexer Software mit einem guten Design viele Abhängigkeiten auflösen kann. Das vereinfacht nicht nur den Produktivcode, sondern auch die Tests. Und einfacher ist eigentlich immer besser! 🙂

Auch wenn es anscheinend einiges zu verbessern gibt, ist GOOS immer noch ein Klassiker. Wenn du es noch nicht gelesen hast, empfehle ich dir, das nachzuholen. Eine bessere Einführung in testgetriebene Entwicklung von vorne bis hinten kenne ich nicht.

Growing Object-Oriented Software, Guided by Tests - Amazon (Affiliate)*

Kennst du das GOOS-Buch? Was hältst du davon? Und wie stehst du zu Mocks in deinen Unit-Tests?

Domain Driven Design

Einführung in Domain Driven Design

Veröffentlicht am 12.08.2016

In diesem Artikel bei heise Developer zeigt Golo Roden kurz und knapp die wichtigsten Bestandteile von DDD: Domain-driven Design erklärt | heise Developer (Link: http://www.heise.de/developer/artikel/Domain-driven-Design-erklaert-3130720.html). Als Einführung ins Thema kann ich den Artikel jedem Azubi wärmstens empfehlen.

Alle wichtigen Begriffe – z.B. Entities, Value Objects und Aggregates – werden erläutert und in den Kontext von DDD einsortiert. Ein paar Codeschnipsel sind auch dabei.

Wer sich bislang noch nicht mit DDD auseinandergesetzt hat, dem empfehle ich dringend, dies nachzuholen. Die Programme, die sich beim Einsatz von DDD ergeben, sind erstaunlich gut wart- und erweiterbar. Und sie passen auch hervorragend in moderne Architekturen, wie Torben Fojuth in diesem Artikel beschreibt: Domain-Driven Design im Hexagon – Informatik Aktuell (Link: http://www.informatik-aktuell.de/entwicklung/methoden/domain-driven-design-im-hexagon.html).

Meine letzten Projekte habe ich auch – sehr erfolgreich – nach dem Prinzip des Domain Driven Design umgesetzt.

Setzt du DDD in deinen Projekten ein? Oder verwendest du eine andere Vorgehensweise bei der Softwareentwicklung?

Kommentare

  • Von Katja am 12.08.2016
    Danke für den Hinweis auf den interessanten Artikel. Das war sehr interessant für mich. Mal schauen, ob ich davon was umsetzen kann.

  • Von Stefan Macke am 12.08.2016
    Gern geschehen. Ich freue mich über einen Kommentar, wenn du es ausprobiert hast 🙂

  • Von Golo Roden (Link: http://www.thenativeweb.io) am 04.01.2017
    Vielen Dank für das Verlinken meines Artikels! Ich bin gerade durch Zufall darauf gestoßen, und habe mich sehr darüber gefreut 🙂

  • Von Stefan Macke am 04.01.2017
    Gern geschehen. Ich bin immer auf der Suche nach guten Ressourcen für die Ausbildung von Anwendungsentwicklern. Und der Artikel gehört definitiv dazu! 🙂

Bewerber programmieren lassen

Warum man Bewerber programmieren lassen sollte

Veröffentlicht am 05.08.2016

Phil Calçado beschreibt in diesem Artikel die Evolution des Einstellungsprozesses, die er bei mehreren Unternehmen – u.a. ThoughtWorks und SoundCloud – mitgemacht hat: On asking job candidates to code (Link: http://philcalcado.com/2016/03/15/on_asking_job_candidates_to_code.html).

Er beginnt mit der Auswahl von Kandidaten für Entwicklerpositionen anhand der Bücher, die sie gelesen haben. Das trennt bereits die Spreu vom Weizen, da „schlechte“ Programmierer häufig keine technischen Bücher lesen.

Danach geht es weiter mit dem obligatorischen „Live Coding“. Das machen wir tatsächlich auch so: Bewerber müssen zunächst im Pair Programming zeigen, ob sie wirklich programmieren können, und wenn ja, wie sie Probleme lösen. Ganz nebenbei lernen sich die beiden Entwickler auch persönlich kennen und man kann danach besser einschätzen, ob der Bewerber ins Team passt.

Die letzte Stufe der Evolution ist eine vorgefertigte Test Suite, die den Kandidaten zugesendet wird. Erst wenn alle Tests grün sind, ist die Aufgabe gelöst. Das erspart den Einstellenden das mühsame Auswerten des Codes der Kandidaten. Das ist aber wohl nur sinnvoll, wenn man regelmäßig viele Bewerber hat.

Ich fand den Artikel sehr interessant, da sich ein ähnliches Ergebnis bei uns gezeigt hat. Viele Bewerber können leider einfach nicht richtig programmieren! Und das geht schon bei Kleinigkeiten wie einer for-Schleife los. Diese „Entwickler“ werden durch ein Verfahren wie das obige schnell aussortiert und belasten den Einstellenden nicht unnötig.

Wie läuft der Einstellungsprozess in deinem Unternehmen ab? Stellt ihr seltsame Fragen im Vorstellungsgespräch oder lasst die Kandidaten programmieren?

Kommentare

  • Von Pascal (Link: http://www.codefieber.de/) am 05.08.2016
    Hi, die Frage ist, was wird dann da an Code verlangt? Ich wurde auch mal gefragt wie ich ein „Bubblesort“ programmieren würde und sollte das dann aufmalen. Aber was war denn überhaupt ein „Bubblesort“? Kannte ich bis dato nicht. Und nun? Schlussendlich hatte mir das Unternehmen sowieso nicht gefallen, insofern war es nicht tragisch dort nicht genommen worden zu sein. Andererseits (auch dort war es nicht tragisch), hatte ich mal eine Aufgabe mit Datenbanken, wenn dann auch noch zwei Leute über die Schulter gucken und du da im Anzug sitzt und die Schweißperlen runterlaufen… Jo, muss irgendwie nicht sein. Danach kam dann noch eine Aufgabe nach Hause. Ein Programm mit Datenbank und entsprechender Datenbankabfrage. Einen Datenbankhelper hatte ich als static deklariert, da lässt sich drüber streiten, ob das nun gut oder schlecht ist. Aber wozu daraus ein Objekt machen? Ende vom Lied war, das sei ja nicht Objektorientiert und schlecht und bla bla bla. Komische Firma -> wollte ich eh nicht hin. Also von mir aus lasst den Bewerber eine Aufgabe zuhause machen – in Ruhe! Und nicht wenn da zig Leute über die Schulter schauen. Achso und 1 Tag Probearbeiten musste ich auch schon, wo ich mich dann frage, wie soll man das als Berufstätiger machen. Da wird man dann genötigt 1 kostbaren Tag Urlaub zu nehmen, nur für die Firma. Um später eine Absage zu erhalten? Das kann doch nicht deren Ernst sein. Also es gibt ja nun genügend andere Auswahlverfahren und die Firmen die Interesse hatten, hatten so einen Spielkram auch nicht gemacht. Viele Grüße!

  • Von Stefan Macke am 05.08.2016
    Hallo Pascal,

    danke für dein Feedback. Du siehst das Ganze natürlich hauptsächlich aus Sicht des Bewerbers. Aber wenn du auf der anderen Seite sitzt, denkst du vielleicht etwas anders. Wenn du jemanden einstellst, der sich im Nachhinein als schlechter Programmierer herausstellt, war der ganze Aufwand für den Bewerbungsprozess umsonst und du hast einen Haufen Kosten verursacht. Und die Kosten wachsen noch an, wenn du den Entwickler weiter beschäftigen musst. Ich halte es daher für unerlässlich, Bewerber auf Entwicklerstellen programmieren zu lassen. Wohlgemerkt rede ich hier nicht von Azubis, sondern von fertigen Entwicklern.

    Das Programmieren an der Tafel oder vor einem großen „Publikum“ finde ich auch unsinnig. Bei uns gibt es ein Pair Programming mit einer anderen Person und das war’s. Wer so einer Situation – die im Alltag ganz normal ist – nicht gewachsen ist, ist dann meiner Meinung nach halt eben nicht der richtige Kandidat.

    Ich würde auch keinen Bewerber ablehnen, weil er mal eine Methode static macht. Sofern er die Vor- und Nachteile und vor allem seine Entscheidung sauber begründen kann, ist das doch völlig in Ordnung.

    Und zum „wertvollen“ Urlaubstag: Na klar ist das kostbare Freizeit des Bewerbers. Aber er bewirbt sich ja nicht umsonst. Vielfach ist doch z.B. ein Gehaltsanstieg zu erwarten oder überhaupt ein besserer Job. Ich denke, dass man da durchaus auch von einem Bewerber etwas Einsatz erwarten darf. Und bei uns werden auch nicht wahllos 20 Leute zum Probearbeiten eingeladen (denn das geht ja auch von unserer eigenen Zeit ab!), sondern z.B. nur die letzten 3. Daher ist die Chance, den Job dann letztlich zu bekommen, also nicht so schlecht.

    Viele Grüße! Stefan

  • Von Michael am 13.01.2018
    Hallo, ich habe Ihre Seite in meine Ausbildung sehr genossen und stark verfolgt… nun bin ich fertig und auf der Suche nach einen Job… Was kann man erwarten, welche Aufgaben, welche Schwierigkeitsgrad in einem Probetag in der PHP entwicklung… Die Firma entwickelt CRM . Wenn Sie paar Aufgaben vorschlagen würden, was Sie in den Probetag als Aufgaben stellen würden ! (für den Berufsanfänger) Danke

  • Von Stefan Macke am 14.01.2018
    Hallo Michael,

    das kommt sicherlich stark auf das Unternehmen an. Ich persönlich habe bislang immer relativ einfache Aufgaben gestellt, wie z.B. FizzBuzz oder das Game of Life. Dabei trennt sich schon die Spreu vom Weizen 🙂

    Viele Grüße! Stefan

Teambuilding-Übungen

Übungen zum Teambuilding

Veröffentlicht am 29.07.2016

Vor Kurzem durfte ich eine kleine Veranstaltung für unsere Abteilung organisieren und war auf der Suche nach Möglichkeiten für die Gestaltung der „Freizeit“. Dabei bin ich auf diesen Artikel gestoßen: Teambuilding: 27 Übungen für besseren Teamgeist (Link: https://www.lecturio.de/magazin/teambuilding-uebungen/).

Der Artikel listet 27 Übungen auf, mit denen ein Team in allen klassischen Phasen der Teamentwicklung (die darf man übrigens auch für die Abschlussprüfung kennen 😉 ) unterstützt und gestärkt werden kann. Einige kannte ich bereits, aber von anderen habe ich bislang noch nichts gehört.

Die einzelnen Übungen sind recht knapp erläutert und viele wird man nicht ohne weitere Lektüre oder einen Coach anwenden können, aber die Liste bietet einen schönen Überblick über mögliche Aktivitäten zur Stärkung des Teamgefühls.

Hast du schon einmal an einer Teambuildung-Maßnahme teilgenommen? Welche Übungen habt ihr dabei durchgeführt?

Kommentare

  • Von Sabine Schneider (Link: http://www.teamevent-plus.de) am 06.04.2017
    Eine weitere Möglichkeit, ein effektives Team-Building durchzuführen, ist ein soziales Teamevent. Der Mehrwert entsteht durch die Kombination des Teambuilding-Einsatzes mit einem sozialen Engagement. Mitarbeiter renovieren gemeinsam in einer Kindereinrichtung, helfen einer Organisation für beeinträchtigte Menschen oder sorgen im Seniorenheim für Abwechslung. Das gemeinsame Tun schweißt nachweislich zusammen und bekommt durch den gesellschaftlichen Hintergrund eine zusätzliche Wirkung.

Nachteile der Vererbung

Warum die Vererbung nicht alle Probleme löst

Veröffentlicht am 22.07.2016

Das Thema Vererbung spielt in der Objektorientierung eine wichtige Rolle. Nicht umsonst ist es auch zentraler Bestandteil der Abschlussprüfung. Ich habe sogar eine separate Podcast-Episode dazu aufgenommen: Anwendungsentwickler-Podcast #8: Häufige Fragen im Fachgespräch – Vererbung.

Beate Ritterbach geht in diesem Artikel bei heise Developer auf die Vererbung und ihre Unzulänglichkeiten ein: Vererbung: für Objekte nützlich, für Werte gefährlich | heise Developer (Link: http://www.heise.de/developer/artikel/Vererbung-fuer-Objekte-nuetzlich-fuer-Werte-gefaehrlich-3254433.html).

Anhand gut verständlicher Beispiele wie dem Kreis-Ellipsen-Dilemma zeigt sie, wo die Vererbung ihre Schwachstellen hat bzw. wofür sie einfach nicht geeignet ist. Der Artikel zeigt sehr schön, dass man als Entwickler eben gerade nicht immer alle Probleme mit den verfügbaren Mitteln der Programmiersprache lösen muss oder kann.

Dazu passt sehr schön das folgende Zitat von Paul Watzlawick:

Wer als Werkzeug nur einen Hammer hat, sieht in jedem Problem einen Nagel.

Wer als Prüfling eine Diskussion wie die aus dem Artikel im Fachgespräch abliefern kann, ist auf direktem Weg zur „1“ 🙂 Daher gibt es eine unbedingte Leseempfehlung von mir!

Hattest du auch schon einmal einen Fall, bei dem du mit Vererbung arbeiten wolltest, aber sie sich als unpassend herausstellte? Setzt du häufig Vererbung in deinem Code ein?

Kommentare

  • Von Anne am 25.07.2016
    Wir haben ein Projekt, bei dem Interfaces meines Erachtens falsch benutzt wurden. Es gibt z.B ein Interface CrudController, in dem simple Methoden für die CRUD-Operationen definiert sind. In vielen Controllern reichen die simplen Entitäten aber nicht, sonder ich brauche noch den aktuellen Nutzer, hochgeladene Dateien o.Ä.. Das führt dazu, dass einige Methoden nur existieren, um das Interface zu implementieren, aber eigentlich deprecated sind und auch absolut nix tun. Oder Fälle, wo in der Super-Klasse eine ungewollte Veränderung vorgenommen wird, welche dann von der Kind Klasse wieder „kompensiert“ werden muss. Hier hätte ich mit mehreren kleinen Methoden gearbeitet, oder die Eltern Klasse abstrakt gemacht und Teile der Implementierung an die Kind-Klassen weitergegeben.

  • Von Stefan Macke am 26.07.2016
    Hallo Anne,

    schöne Beispiele für die Verletzung des Interface Segregation Principle! Das ist eines der SOLID-Prinzipien und besagt, dass Interfaces so klein wie möglich sein sollten, um genau die von dir beschriebenen Probleme zu vermeiden. Siehe z.B. Interface Segregation Principle | Object Oriented Design (Link: http://www.oodesign.com/interface-segregation-principle.html).

    Viele Grüße! Stefan

Kontroverse Meinungen zur Programmierung

Kontroverse Meinungen zur Programmierung

Veröffentlicht am 15.07.2016

In diesem schon etwas älteren Artikel listet Yannis Rizos einige kontroverse Meinungen aus dem Bereich der Programmierung auf: 20 controversial programming opinions « Programmers Stack Exchange Blog (Link: http://programmers.blogoverflow.com/2012/08/20-controversial-programming-opinions/). Vielleicht geben sie dir ja auch einen Denkanstoß.

Mit dabei sind „Klassiker“ wie gute Entwickler müssen auch in ihrer Freizeit programmieren oder der 10x-Rockstar-Ninja-Programmierer. Aber auch Java als häufige Einstiegssprache wird in Frage gestellt oder das Ich bin ein Puts-Debuggerer empfohlen.

Einige Meinungen würde ich persönlich schon als definitive Regeln verstehen, z.B. dass nicht für jedes Attribut einer Klasse automatisch Getter und Setter angelegt werden sollten (bricht die Anwendungsentwickler-Podcast #6: Häufige Fragen im Fachgespräch – Kapselung auf) oder dass man als Programmierer, nun ja, programmieren können sollte. Die Beispielaufgabe zur Berechnung von Pi verwende ich übrigens in meiner eigenen Vorlesung. Und viele Studierende verbringen viiiieeel Zeit mit der Lösung 😉

Ich finde die Liste von Yannis sehr interessant und kann bei vielen Punkten verstehen, warum sie kontrovers diskutiert werden. Oft sind sowohl die Argumentation dafür, als auch die dagegen gut nachvollziehbar. Das ist immer ein guter Anreiz, um einmal seine eigene Meinung zu hinterfragen bzw. sich überhaupt selbst eine Meinung zu bilden.

Welchen kontroversen Aussagen würdest du zustimmen oder widersprechen? Hast du noch weitere Punkte für die Liste?

Wie werde ich Fachinformatiker?

Wie werde ich Fachinformatiker?

Veröffentlicht am 08.07.2016

Daniel Bocksteger hat in seinem Blog auf werd-fachinformatiker.de (Link: http://werd-fachinformatiker.de) eine Artikelreihe zum Thema Wie werde ich Fachinformatiker | Werd Fachinformatiker (Link: http://werd-fachinformatiker.de/wie-werde-ich-fachinformatiker/5354/) veröffentlicht. Sie gibt einen guten Überblick über die einzelnen Phasen der Ausbildung und auch über zwei Bereiche, die ich hier bislang vernachlässigt habe (weil ich dazu wenig sagen kann): die Fachinformatiker werden -#4 Zwischenprüfung | Werd Fachinformatiker (Link: http://werd-fachinformatiker.de/fachinformatiker-werden-zwischenpruefung/5570/) und die Arbeit in der Fachinformatiker werden -#3 Unterricht in der Berufsschule | Werd Fachinformatiker (Link: http://werd-fachinformatiker.de/berufsschule-unterricht/5534/).

Daniel stellt in seinem Blog auch regelmäßig interessante Bücher rund um die Ausbildung zum Fachinformatiker vor. Den Fokus legt er dabei auf die Entwicklung von mobilen Anwendungen und auch auf Bereiche aus dem Design wie die Gestaltung von Websites und die Fotografie. Für mich immer sehr spannend, da ich privat auch gerne mit meiner Canon EOS 700D SLR-Digitalkamera 3 Zoll Kit inkl. EF-S (Affiliate)* experimentiere.

Wenn du auch in der mobilen Entwicklung unterwegs bist, ist Daniels Blog definitiv einen Besuch wert. Auch wenn du bereits Fachinformatiker bist. 😉

Haben dir die Inhalte von Daniel gefallen? Dann schreib ihm doch einen Kommentar! Kennst du noch weitere Blogs zum Thema, die ich hier empfehlen kann? Dann Kontaktformular (Link: /kontakt/).

Kommentare

  • Von Daniel Bocksteger (Link: http://Www.werd-fachinformatiker.de) am 09.07.2016
    Hi Stefan! Vielen vielen Dank für den Hinweis auf unseren Blog! Wir hoffen sehr, dass wir den ein oder anderen mit unseren Artikeln besonders bei der Entscheidung, ob der Beruf etwas für ihn ist, unterstützen können! Auch über Leser-Feedback und Kommentare freuen wir uns sehr! Deshalb gibt es unter jedem der Artikel auch eine „Fragerunde“, mit der wir ungeklärte Fragen und Probleme klären und sammeln möchten. Viele grüße, Daniel

Multitasking ist ein Mythos

Warum Multitasking nicht funktioniert

Veröffentlicht am 27.05.2016

Springst du bei der Arbeit auch ständig zwischen verschiedenen Aufgaben hin und her? Checkst du während der Build deines Programms läuft auch nur eben schnell deine Mails? Dann habe ich diese Woche einen interessanten Artikel für Dich: Multitasking is Killing Your Brain — Life Tips. — Medium (Link: https://medium.com/life-tips/multitasking-is-killing-your-brain-79104e62e930#.v187a1v1m).

Darin erklärt Larry Kim, warum Multitasking nicht funktioniert. Stattdessen solltest du dich – gerade als Softwareentwickler/in – ausschließlich auf eine Sache gleichzeitig konzentrieren. Und das gilt auch, wenn du eine Frau bist. Denn Multitasking beherrscht weder das männliche, noch das weibliche Gehirn.

Passend zu diesem Thema habe ich vor Kurzem auch ein sehr spannendes Hörbuch gehört (oder sagt man auch „gelesen“?): The One Thing: The surprisingly simple truth behind extraordinary results (Affiliate)* ist ein komplettes Buch, dass sich auf die Umsetzung einer einzigen Sache konzentriert, bis man sie vollständig umgesetzt hat. Erst danach sollte man sich der nächsten Aufgabe widmen. Ich kann das Buch absolut empfehlen.

The One Thing: The surprisingly simple truth behind extraordinary results (Affiliate)*

Das Hörbuch kann man übrigens perfekt hören, wenn man gerade eine andere Aufgabe abarbeitet – z.B. Abwaschen oder Rasen mähen. Dabei weiche ich gerne von der Kein-Multitasking-Regel ab! 😉

The ONE Thing: The Surprisingly Simple Truth Behind Extraordinary Results (Hörbuch-Download): Gary Keller, Jay Papasan, Timothy Miller, Claire Hamilton (Affiliate)*

Wie organisierst du deine Arbeit? Wechselst du ständig die Aufgaben oder konzentrierst du dich auf eine Aufgabe so lange bis sie umgesetzt ist?

Kommentare

  • Von Severin Sigl am 27.05.2016
    Hört sich an wie fast jedes Productivity/Success/… Buch und die Reviews bestätigen das auch: http://www.goodreads.com/book/show/16256798-the-one-thing Die eine Hälfte liest zum ersten mal so ein Buch und die andere bestätigt, dass es nichts neues ist: „I disliked the book, it’s a meshed up version other self help books, like „How to win friends and influence people“ from Dale Carnegie; „Think and grow rich“ from Napoleon Hill and others alike. It’s a boring read, you get the message 20 pages into the book, and the rest of the book is repetitive.“ „The reason I give it 2 starts is that at least the main message is interesting, focus in accomplish one thing at a time, forget everything else. That’s it, I just gave you the whole book and saved you some money.“

  • Von Stefan Macke am 27.05.2016
    Hallo Severin,

    na klar, die Aussage ist etwas generisch. Und natürlich gibt es noch einen Haufen andere Zeitmanagement-Bücher. Ich habe auch viele davon bereits gehört oder gelesen, z.B. „7 Habits of Highly Effective People“ und tatsächlich auch die beiden aus deinem Kommentar!

    Dennoch fand ich das (Hör-)Buch sehr interessant. Auch wenn mir schon einige Ansätze aus anderen Bücher bekannt waren, sind sie hier noch einmal schön zusammengefasst. Und das Buch hat mich einfach nochmal motiviert, über meine tägliche Arbeit und meinen Fokus nachzudenken. Daher empfehle ich es weiter.

    Viele Grüße! Stefan

Wie man gute Commit-Meldungen schreibt

Wie man eine gute Git-Commit-Nachricht schreibt

Veröffentlicht am 20.05.2016

In diesem Artikel beschreibt Chris Beams wie man eine gute Git-Commit-Nachricht formuliert: How to Write a Git Commit Message (Link: http://chris.beams.io/posts/git-commit/).

Er stellt dafür sieben Regeln auf:

  • Subject und Body mit einer Leerzeile trennen.
  • Subject auf 50 Zeichen beschränken.
  • Subject mit einem Großbuchstaben beginnen.
  • Subject nicht mit einem Punkt beenden.
  • Im Subject den Imperativ benutzen.
  • Den Body bei 72 Zeichen umbrechen.
  • Erklären was und warum geändert wurde und nicht wie.

Seit Blog von Markus Amshove (Link: https://amshove.org/) mir den Artikel geschickt hat, versuche ich selbst, mich an die Empfehlung des Autors zu halten. Und ich denke, die Vorgabe ist gerade für junge Entwickler sehr hilfreich. Oftmals sehe ich nämlich Nachrichten im Log wie

Verschiedene Änderungen am Programm

oder

Refactoring

Besonders bitter ist es, wenn die letzten Commits alle dieselbe Nachricht enthalten. Da wusste der Programmierer wohl selbst nicht, was er eigentlich gemacht hat.

Das geht so lange gut, wie man die Historie nicht benötigt, um eine gewisse Änderung nachzuvollziehen. Dann wird es nämlich sehr schwer, die betreffenden Commits zu identifizieren.

Also meine klare Empfehlung an jeden Azubi: Gewöhn dir gleich an, sprechende und hilfreiche Commit-Messages zu formulieren, die beschreiben, warum etwas geändert wurde und nicht wie (denn dafür ist die Software da).

Wie formulierst du die Commit-Nachrichten in deinem Versionsverwaltungssystem? Gibt es Regeln, an die du dich hältst?

Kommentare

  • Von Christian (Link: http://www.i-write-code.de) am 20.05.2016
    Wie ich Commit Messages schreibe, habe ich gerade erst hier (Link: http://www.i-write-code.de/2016/05/18/commit-messages/) beschrieben 😉 TL;DR Im Prinzip halte ich mich dabei auch an das Schema wie im Artikel oben. Den selbst kannte ich, in diesem Artikel von Tim Poke (Link: http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html) ist aber ein ähnliches (sogar das gleiche?) Schema beschrieben. Schön ist auch der Lightning Talk (Link: https://www.youtube.com/watch?v=8YjSty6bfog) zu dem Thema von Ryan McGeary.

  • Von Stefan Macke am 20.05.2016
    Klasse Ergänzung zum Artikel! Danke für die Links.

    Und dein Blog ist auch gleich im RSS-Reader gelandet! 😀

  • Von Mein Arbeits-Tagebuch › Die zwei Seiten der IT (Link: https://www.juengling-edv.de/mein-arbeits-tagebuch/) am 30.10.2017
    […] ist Was macht eine gute (Git/SVN) Commit-Nachricht aus?, auf die sehr oft Bezug genommen wird (z.B. hier). Praktisch, da muss ich hier nicht alles wiederholen […]

  • Von Ikem (Link: https://ikem-krueger.github.io/) am 29.11.2017

    Dann wir es nämlich sehr schwer, die betreffenden Commits zu identifizieren. Typo.

  • Von Stefan Macke am 01.12.2017
    Danke!

Entwickler-Umfrage von StackOverflow 2016

Ergebnisse der Entwickler-Umfrage 2016 von StackOverflow

Veröffentlicht am 13.05.2016

In diesem Artikel fasst Quincy Larson einige überraschende Ergebnisse der aktuellen Umfrage von StackOverflow unter 50.000 Software-Entwicklern zusammen: Insights from Stack Overflow’s 2016 survey of 50,000 developers — Free Code Camp (Link: https://medium.freecodecamp.com/2-out-of-3-developers-are-self-taught-and-other-insights-from-stack-overflow-s-2016-survey-of-50-8cf0ee5d4c21).

So kann man zum Beispiel gut erkennen, das es fast zehn Mal so viele männliche Entwickler gibt wie weibliche. Sehr interessant finde ich auch die Einkommensspanne amerikanischer Programmierer. Die Gehälter liegen deutlich über dem Durchschnitt der deutschen Anwendungsentwickler.

Interessant ist auch, dass die meisten Besucher der Seite sich anscheinend selbst programmieren beigebracht und keine „offizielle“ Ausbildung genossen haben. Das lässt sich so sicherlich nicht auf den deutschen Markt übertragen. Zumindest ist das meine Einschätzung.

Ich finde die Umfrage von StackOverflow sehr spannend, da die Seite selbst ja schon zum Synonym für Programmieren geworden ist. Letztens gab es passend dazu auch einen witzigen „Buchvorschlag“ für O’Reilly 😀

Findest du dich in den Umfrageergebnissen wieder? Wie bewertest du die einzelnen Ergebnisse?

Ich bin ein Puts Debuggerer

Ich bin ein Puts-Debuggerer

Veröffentlicht am 06.05.2016

Mein Link der Woche ist dieses Mal ein Artikel von Aaron Patterson: I am a puts debuggerer | Tenderlovemaking (Link: https://tenderlovemaking.com/2016/02/05/i-am-a-puts-debuggerer.html). Der Autor beschreibt darin, wie er seine Software debuggt (ja, Konjugation | debuggen | Deutsche Verben konjugieren (Link: http://www.verbformen.de/konjugation/debuggen.htm) 😉 ). Er verwendet keinen Debugger, sondern nutzt einfach die Konsolenausgabe für die Fehlersuche in seinen Programmen (puts in Ruby, daher der Name des Artikels).

Der Vorteil des puts-Debuggens zur Fehleranalyse ist, dass man keine aufwendige Entwicklungsumgebung dafür benötigt. Kommandozeilenausgaben kann man auch mit simplen Editoren in den Code einbauen. Aaron zeigt in seinem Artikel die Erfahrungen, die er in den letzten Jahren mit seiner Methode gemacht hat. Ich selbst konnte noch ein paar interessante Tricks aus dem Artikel mitnehmen. Auch wenn die Programmiersprache Ruby ist, sind die gezeigten Prinzipien auch auf jede andere Programmiersprache übertragbar. Witzig fand ich zum Beispiel den letzten Tipp, in dessen Konsolenausgabe ich mich selbst wiedergefunden habe. Die vielen Hashes (#), um die Debugausgaben schneller finden zu können, erinnern mich stark an meine eigene Fehlersuche. 😀

Ich selbst habe auch schon seit Jahren keinen Debugger mehr verwendet. In Zeiten von testgetriebener Softwareentwicklung ist das meiner Meinung nach auch völlig überflüssig, da mir die Tests zeigen, wenn es einen Fehler in der Software gibt. Und wenn ich mehr über den Zustand des Programms zur Ausführung wissen möchte, verwende ich genau wie Aaron die Konsolenausgabe, um mir Werte von Variablen, Schleifenzähler oder sonstige Inhalte auszugeben. Meine Azubis fragen mich teilweise nach mehreren Monaten oder ganzen Ausbildungsjahren, was überhaupt ein Debugger ist und wie man ihn verwendet. Und das ist gut so!

Wie suchst du Fehler in deiner Software? Verwendest du einen Debugger oder nutzt du auch die Kommandozeile, um den Zustand deines Programms zu untersuchen?

Kommentare

  • Von Pascal am 10.05.2016
    Hallo, ich finde die Arbeit mit einem Debugger (in PHP und Java) großartig. So kann ich älteren Code oder Code, der nicht getestet ist, nochmal gut nachvollziehen. Wenn es viele Sachen gibt, wo man gar nicht weiß, was das Stückchen Code hier macht, sollte man, finde ich, mit einem Debugger reingucken. Dazu muss ich sagen, dass ich sehr wenig Erfahrung mit Tests (Unittests oder andere Art) habe, sodass ich häufig auch den Debugger während der Entwicklung am laufen habe, um mich so zu kontrollieren, was ich in welchem Format wie bearbeite. (Gerade mit Schleifen, was wo wann wer welche Variable hat etc.) Gruß

  • Von Stefan Macke am 11.05.2016
    Hallo Pascal,

    das kann ich nachvollziehen. Als ich angefangen habe zu programmieren, habe ich auch ständig einen Debugger benutzt. Durch den Umstieg auf automatische Tests ist dieser für mich jedoch überflüssig geworden. Ein weiterer Vorteil der Test ist auch, dass ich sie regelmäßig laufen lassen kann und nicht auf interaktive Debugging-Sitzungen angewiesen bin.

    Viele Grüße! Stefan

Java EE 7 Application Server im Vergleich

Vergleich aller Java EE 7 Application Server

Veröffentlicht am 29.04.2016

Von wegen schwergewichtig – Moderne Webentwicklung mit Java EE 7 habe ich ja schon erläutert, dass moderne Webentwicklung mit Java EE 7 nicht mehr schwergewichtig und langsam sein muss. Und dieser Artikel von Antonio Goncalves belegt das noch einmal eindrücklich: O Java EE 7 Application Servers, Where Art Thou? – DZone Java (Link: https://dzone.com/articles/o-java-ee-7-application-servers-where-art-thou)

Antonio hat einen Benchmark aller möglichen Application Server durchgeführt und die Ergebnisse gegenübergestellt. Man kann z.B. deutlich erkennen, dass der Großteil der Server in unter 3 Sekunden gestartet ist, besonders leichtgewichtige Varianten sogar in 0,5 Sekunden. Wenn ich das mit rails server vergleiche, ist das schon ein sehr guter Wert 😉

Aber auch der geringe Speicherverbrauch der Application Server ist bemerkenswert: ein Apache TomEE & OpenEJB (Link: http://tomee.apache.org/) ist mit knapp 50 MB dabei, der von mir genutzte WildFly Homepage · WildFly (Link: http://wildfly.org/) mit ca. 100 MB. Während ich diesen Artikel schreibe verbraucht mein aktuelles Firefox-Fenster hingegen 362 MB RAM! Und darin ist keine komplette Laufzeitumgebung und virtuelle Maschine für Java-Anwendungen enthalten.

Ich denke, die Zahlen belegen eindrucksvoll, dass nicht nur das Programmiermodell von Java EE 7 eine große Entwicklung darstellt, sondern auch die – lange Zeit als Ressourcenfresser verschrienen – Application Server inzwischen den Stempel „leichtgewichtig“ verdienen.

Welchen Ressourcenverbrauch haben deine Anwendungen bzw. ihre Laufzeitumgebungen? Findest du die obigen Angaben gut oder schlecht?

Persistenz- vs Domänenmodell

Domänen- vs. Persistenzmodell

Veröffentlicht am 22.04.2016

In diesem gut geschriebenen Artikel vergleicht Mehdi Khalili unterschiedliche Ansätze zur Trennung eines Persistenz- und Domänenmodells bei der Softwareentwicklung: ORM anti-patterns – Part 4: Persistence vs Domain Model (Link: http://www.mehdi-khalili.com/orm-anti-patterns-part-4-persistence-domain-model/). Obwohl der Artikel schon von 2011 ist, finde ich ihn immer noch höchst relevant für die Praxis. Gerade vor Kurzem habe ich mit meinen Azubis über die Vor- und Nachteile verschiedener Möglichkeiten bei der Trennung von Persistenz- und Geschäftslogik gesprochen.

Es gibt meiner Meinung nach kein Allheilmittel für die Abbildung von objektorientierten Domänenmodellen auf relationale Persistenzmodelle. Auch ORMs machen uns das Leben zwar grundsätzlich leichter (immerhin müssen wir kein SQL mehr schreiben), aber sie führen durchaus neue Probleme oder Fragestellungen ein. Alle vorgestellten Lösungsansätze haben Vor- und Nachteile, die es gegeneinander abzuwiegen gilt.

Der obige Artikel verdeutlich schön die zu berücksichtigenden Punkte verschiedener Ansätze, z.B. der kompletten Trennung beider Modelle (was zu Redundanzen und nervigen Mappings führt, aber eine freie Evolvierbarkeit beider Modelle ermöglicht). Ich empfehle ihn jedem Softwareentwickler, der sich mit der Speicherung seiner Daten in einer relationalen Datenbank auseinandersetzen muss.

Welche Technologien verwendest du für die Persistenz? Verfolgst du eine bestimmte Strategie bei der Speicherung deiner Daten in der Datenbank?

Die Macht regulärer Ausdrücke

Veröffentlicht am 15.04.2016

Ich schwärme immer mal wieder von regulären Ausdrücken. Das liegt wohl einfach daran, dass ich fast täglich mit ihnen arbeite. Sie sind einfach so unglaublich vielseitig verwendbar und machen ITlern das Leben leichter – wenn man sie beherrscht.

Nicht umsonst gibt es diesen „Witz“:

Ich hatte ein Problem und versuchte es mit regulären Ausdrücken zu lösen. Nun habe ich zwei Probleme.

In den Händen eines erfahrenen Anwenders sind reguläre Ausdrücke allerdings äußerst hilfreich. Gerade vor wenigen Tagen hatte ich die – eigentlich triviale – Aufgabe, ein paar Dateien umzubenennen, die ein bestimmtes Präfix hatten. Dieses Präfix sollte ausgetauscht werden. Anstatt die Dateien per Hand umzubenennen (oder die entsprechende Shell-Funktion zu nutzen: bash – How to rename with prefix/suffix? (Link: http://stackoverflow.com/questions/208181/how-to-rename-with-prefix-suffix) 😉 ), habe ich mir mit einem simplen regulären Ausdruck in wenigen Sekunden ein Shell-Script gebaut, das die Aufgabe für mich löst.

prefix-Datei1.txt
prefix-Datei2.txt
...
prefix-Datei100.txt

Mit dem Suchen-/Ersetzen-Muster /^(prefix-(.*))$/move $1 neuerPrefix-$2/g wird daraus:

move prefix-Datei1.txt neuerPrefix-Datei1.txt
move prefix-Datei2.txt neuerPrefix-Datei2.txt
...
move prefix-Datei100.txt neuerPrefix-Datei100.txt

In diesem tollen Artikel geht Nikita Popov auf die Hintergründe von regulären Ausdrücken ein und erklärt ganz nebenbei noch die Chomsky-Hierarchie (Link: https://de.wikipedia.org/wiki/Chomsky-Hierarchie) und warum man HTML nicht mit regulären Ausdrücken parsen sollte: The true power of regular expressions (Link: http://nikic.github.io/2012/06/15/The-true-power-of-regular-expressions.html). Ein wirklich spannender Artikel, der mir wieder mal zeigt, wie sinnvoll es ist, reguläre Ausdrücke zu beherrschen.

Eine witzige Möglichkeit, reguläre Ausdrücke zu lernen, ist übrigens das Regex Crossword (Link: https://regexcrossword.com/). Damit habe ich auch schon einige Stunden verbracht 😀

Wofür verwendest du reguläre Ausdrücke? Wie haben sie dir vielleicht schon deine Arbeit erleichtert?

Java EE 7 Hands On

Java EE 7 Hands-on Lab

Veröffentlicht am 08.04.2016

Arun Gupta bei Twitter (Link: https://twitter.com/arungupta) zeigt in diesem Hands-on Lab zu seiner Java EE-Schulung, was mit Java EE alles möglich ist: Java EE 7 Hands-on Lab (Link: https://htmlpreview.github.io/?https://github.com/javaee-samples/javaee7-hol/blob/master/docs/javaee7-hol.html).

Arun wendet in seinem Beispielprojekt so ziemlich alles an, was geht, inklusive der Neuerungen in Java EE 7. Hier nur ein paar Beispiele:

  • Java API for WebSocket
  • Batch Applications
  • Java API for JSON Processing
  • Java API for RESTful Web Services
  • Java Message Service

Wer sich nur für Teile des Tutorials interessiert, dem gibt er mit einer Übersicht über die voraussichtliche Bearbeitungszeit der einzelnen Teile eine Entscheidungshilfe. Außerdem geht er auf alle notwendigen Voraussetzungen ein, die für die Umsetzung des Beispielprojekts wichtig sind, wie z.B. die Einrichtung der IDE und der benötigten Bibliotheken.

Ich kann das Tutorial jedem Java EE-Neuling empfehlen. Es ist gut verständlich geschrieben und sehr praxisnah. Und vor allem werden auch ein paar coole neue Technologien verwendet 😀

Welche Einstiegsliteratur zu Java (EE) kannst du empfehlen? Womit hast du den Anfang gemacht?

Der Pade

Prüfungstipps von Patrick Hausmann

Veröffentlicht am 01.04.2016

Patrick Hausmann (Link: http://www.derpade.de/) hat auf seiner Website in letzter Zeit einige interessante Artikel rund um die Abschlussprüfung zum Fachinformatiker veröffentlicht. Er schildert sowohl seine Vorbereitung auf die schriftliche Abschlussprüfung, als auch den Prozess der Projektbearbeitung – vom Antrag bis zum Fachgespräch.

Ich finde die Inhalte gelungen und praxisnah. Da Patrick selbst erst vor Kurzem die Prüfung bestanden hat, kannst du vielleicht von seinen aktuellen Erfahrungen profitieren.

Es geht los mit einer Übersicht der verschiedenen Prüfungen: Übersicht der Abschlussprüfungen als Fachinformatiker (Link: http://www.derpade.de/uebersicht-der-abschlusspruefungen-als-fachinformatiker/). Dann hat Patrick auch eine Liste mit den Prüfungsthemen der vergangenen Jahre erstellt und einige Lösungshinweise ergänzt. Außerdem erklärt er, wie er sich auf die Prüfung vorbereitet hat.

  • GA1 Lernthemen und Lösungen – Fachinformatiker für Anwendungsentwicklung (Link: http://www.derpade.de/ga1-lernthemen-und-loesungen-fachinformatiker-fuer-anwendungsentwicklung/)
  • GA2 Lernthemen und Lösungen – Fachinformatiker für Anwendungsentwicklung (Link: http://www.derpade.de/ga2-lernthemen-und-loesungen-fachinformatiker-fuer-anwendungsentwicklung/)
  • Wie am besten Lernen für Abschlussprüfungen GA1 und GA2 Fachinformatiker (Link: http://www.derpade.de/wie-am-besten-lernen-fuer-abschlusspruefungen-ga1-und-ga2-fachinformatiker/)

Zum Abschlussprojekt gibt es dann noch Hinweise zum Projektantrag, der Projektdokumentation und nicht zuletzt zur Projektpräsentation:

  • Leitfaden Projektdokumentation Fachinformatiker für Anwendungsentwicklung/Systemintegration (Link: http://www.derpade.de/leitfaden-projektdokumentation-fachinformatiker-fuer-anwendungsentwicklungsystemintegration/)
  • Leitfaden Projektantrag Fachinformatiker für Anwendungsentwicklung/Systemintegration (Link: http://www.derpade.de/leitfaden-projektantrag-fachinformatiker-fuer-anwendungsentwicklungsystemintegration/)
  • Vorbereitung Präsentationsprüfung/Fachgespräch – Fachinformatiker (Link: http://www.derpade.de/vorbereitung-praesentationspruefungfachgespraech-fachinformatiker/)

Sein Foliendesign orientiert sich an den „klassischen“ Präsentationen. Davon würde ich persönlich abraten. Aber Patrick hat damit ein „sehr gutes“ Ergebnis eingefahren, also will ich nicht weiter meckern 🙂

Was hältst du von Patricks Beiträgen? Gib ihm doch ein Feedback in den Kommentaren.

Git Cheat Sheet

Git Cheat Sheet

Veröffentlicht am 25.03.2016

Git-Tipps für Fortgeschrittene (aber auch Anfänger), halte ich Git für ein absolutes Muss bei der täglichen Arbeit als Entwickler. Markus Amshove (Link: https://amshove.org/) hat mir einen interessanten Link zu einem Git Commands and Best Practices Cheat Sheet | zeroturnaround.com (Link: http://zeroturnaround.com/rebellabs/git-commands-and-best-practices-cheat-sheet/) empfohlen, den ich hiermit weitergeben möchte. Gerade für Einsteiger dürfte die schöne Visualisierung von Arbeitskopie, Index und Repo hilfreich sein und die Kurzreferenz der wichtigsten Befehle passt sehr gut ausgedruckt unter die Schreibtischunterlage 😉

Von Oleg Šelajev, einem Mitarbeiter von RebelLabs, habe ich auf der JavaLand (Link: http://www.javaland.eu) auch diesen spannenden – und sehr technischen – Vortrag gesehen: Unlocking the magic of monads with Java 8 (Link: https://speakerdeck.com/shelajev/monads-with-java-8-javaland-16). Außerdem führt das Unternehmen regelmäßig Entwickler-Umfragen durch, deren Ergebnisse es dann kostenfrei veröffentlicht. Für jede Teilnahme spendet RebalLabs einen Betrag an eine Initiative für die Heranführung von Kindern an die Programmierung (Devoxx4Kids – Inspire children to programming, robotics and engineering (Link: http://www.devoxx4kids.org/)). Man unterstützt also auch einen guten Zweck. Ich habe bereits teilgenommen!

Developer Productivity Survey 2016: Java Tools and Technologies — Supporting Devoxx4Kids | zeroturnaround.com (Link: http://zeroturnaround.com/rebellabs/developer-productivity-survey-2016-java-tools-and-technologies-supporting-devoxx4kids/)

Wenn du noch mehr über Git lernen willst (was ich jedem Entwickler empfehlen würde), schau dir doch mal Scott Chacon – Pro Git (Affiliate)* an.

Scott Chacon - Pro Git (Affiliate)*

Wie funktioniert eine relationale Datenbank?

Wie funktioniert eigentlich eine relationale Datenbank?

Veröffentlicht am 18.03.2016

Datenbanken – insbesondere relationale – sind ein Werkzeug, mit dem wir Softwareentwickler täglich arbeiten. Doch ich behaupte, dass die wenigsten Programmierer wissen, wie eine Datenbank tatsächlich funktioniert. Wenn du dich auch zur Gruppe dieser Unwissenden zählst, empfehle ich dir den folgenden Beitrag von Coding Geek: How does a relational database work – Coding Geek (Link: http://coding-geek.com/how-databases-work/).

Christophe geht in seinem Artikel sehr ausführlich auf das Innenleben von relationalen Datenbanken ein. Er erklärt z.B. den Query optimization – Wikipedia, the free encyclopedia (Link: https://en.wikipedia.org/wiki/Query_optimization) oder den Pufferpool – Wikipedia (Link: https://de.wikipedia.org/wiki/Pufferpool) und erläutert bis ins Detail, welche schwierigen Probleme eine Datenbank in wenigen Millisekunden löst, wenn wir ein einfaches SELECT absetzen.

Sehr gut gefällt mir am Artikel, dass er mit den mathematischen und informationstechnischen Grundlagen beginnt. Die Komplexität (Informatik) – Wikipedia (Link: https://de.wikipedia.org/wiki/Komplexit%C3%A4t_(Informatik)) von Algorithmen ist genauso Thema wie eine Einführung in Feld (Datentyp) – Wikipedia (Link: https://de.wikipedia.org/wiki/Feld_(Datentyp)), Baum (Graphentheorie) – Wikipedia (Link: https://de.wikipedia.org/wiki/Baum_(Graphentheorie)) und Hashtabelle – Wikipedia (Link: https://de.wikipedia.org/wiki/Hashtabelle). Schön ist auch der Seitenhieb auf die NoSQL – Wikipedia (Link: https://de.wikipedia.org/wiki/NoSQL) am Schluss. 🙂

Der Blog-Beitrag ist keine leichte Kost. Es werden teilweise sehr komplexe Probleme beschrieben und auch interne Abläufe, die für unsere tägliche Arbeit mit Datenbanken selbst keine große Rolle spielen. Aber ich glaube, dass man nur dann sinnvoll eine Technologie einsetzen kann, wenn man sie versteht. Also nimm dir ruhig die Zeit und lies den Artikel! Er enthält viele Informationen, mit denen man in der mündlichen Prüfung glänzen kann.

Falls du (zusätzlich) zu den etablierten relationalen Datenbanken auch mit NoSQL-Datenbanken arbeitest und noch eine gute Einführung in dieses Thema suchst, sei dir Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement (Affiliate)* empfohlen. Das Buch gibt einen tollen Überblick über die verschiedenen Arten von Datenbanken und welche Vor- und Nachteile sie haben. Und keine Angst: Es ist nich so theoretisch wie der Blog-Artikel, sondern steigt sofort mit Praxisbeispielen ein. 🙂

Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement (Affiliate)*

Waren dir die Abläufe im Inneren einer relationalen Datenbank bewusst? Hast du noch weitere Linkempfehlungen rund ums Thema? Dann schreib mir gerne einen Kommentar.

Scrum auf dem Bierdeckel erklärt

Scrum auf dem Bierdeckel erklärt

Veröffentlicht am 11.03.2016

Scrum – Wikipedia (Link: https://de.wikipedia.org/wiki/Scrum) ist eine inzwischen auch häufig bei IHK-Abschlussprojektekten angewendete Entwicklungsmethode. Beim dpunkt-Verlag gibt es eine kostenfreie Broschüre zum Download, die Scrum vollständig auf 29 „Bierdeckeln“ erklärt: dpunkt.verlag :: Scrum – auf dem Bierdeckel erklärt (Link: http://dpunkt.de/material/Scrum/).

Die Broschüre enthält alle wissenswerten Informationen rund um den gesamten Prozess. Sie geht auch auf das Manifesto for Agile Software Development (Link: http://agilemanifesto.org/) ein. Außerdem sind alle Rollen (Scrum Master, Product Owner, Team), Meetings (Sprint Planning, Sprint Review, Sprint Retrospective) und Artefakte (Product Backlog, Sprint Backlog, Produkt) beschrieben. Zusätzlich werden noch Visualisierungsmöglichkeiten wie das beliebte Burn-Down-Chart – Wikipedia (Link: https://de.wikipedia.org/wiki/Burn-Down-Chart) erklärt.

Ich kann jedem Entwickler, der sich bislang vielleicht noch nicht mit Scrum auseinandergesetzt hat, die Broschüre wärmstens empfehlen. Ich habe bisher noch keine bessere deutsche Zusammenfassung des Prozesses gesehen. Und aufgrund des geringen Umfangs eignet sie sich auch sehr gut zum Lernen für die Abschlussprüfung!

Wenn dir die Broschüre gefällt, kann ich dir noch ein Buch empfehlen, an dem einer der beiden Autoren mitgearbeitet hat: Bleek/Wolf – Agile Softwareentwicklung (Affiliate)* Darin werden die drei agilen Methoden Extreme Programming – Wikipedia (Link: https://de.wikipedia.org/wiki/Extreme_Programming), Scrum und Feature Driven Development – Wikipedia (Link: https://de.wikipedia.org/wiki/Feature_Driven_Development) genutzt, um den allgemeinen Ansatz agiler Softwareentwicklung zu erklären. Ich fand es gut zu lesen und es vermittelt die Ideen hinter der agilen Entwicklung sehr verständlich.

Bleek/Wolf - Agile Softwareentwicklung (Affiliate)*

Setzt du Scrum bei der Softwareentwicklung ein? Wenn nein, welchen Entwicklungsprozess verwendest du?

Welche Programmiersprache passt zu dir?

Welche Programmiersprache passt zu dir?

Veröffentlicht am 04.03.2016

Hast du dich auch schon einmal gefragt, warum eine bestimmte Programmiersprache dir besser liegt als eine andere? Warum du irgendwie mehr Spaß bei der Arbeit in Ruby hast, als wenn du Java verwenden musst (oder umgekehrt)? Zach Oakes hat eine interessante Theorie aufgestellt: Es gibt für verschiedene Typen von Entwicklern die passenden Programmiersprachen.

In seinem Artikel Clojure is for type B personalities · GitHub (Link: https://gist.github.com/oakes/c82cd08821ce444be6bf) beschreibt Zach zwei unterschiedliche Arten von Programmierern: Typ A, den gut organisierten Planer, und Typ B, den spontanen und entspannten Entwickler. Und passend dazu gibt es Programmiersprachen wie stark und statisch oder schwach und dynamisch typisierte.

Ich muss sagen, dass ich beide Welten mag und auch mit beiden Paradigmen gut klarkomme. Es kommt immer auf den Anwendungsfall an, wann ich welche Sprache einsetze. Aber es gibt schon einen deutlichen Unterschied bei der Arbeit in den verschieden typisierten Sprachen. Allein die IDE-Unterstützung bei statisch typisierten Sprachen ist z.B. meiner Meinung nach eine große Erleichterung und ein klarer Vorteil gegenüber dynamschen Sprachen.

Ich würde mich allgemein eher der typisierten Fraktion zurechnen (Java, C#). Und du? Welche Sprachen bevorzugst du bei der Arbeit (oder in der Freizeit)? Hast du bestimmte Gründe dafür?

Warum man sich als Softwareentwickler ersetzbar machen sollte

Veröffentlicht am 26.02.2016

Viele Menschen hören nicht gerne, dass sie im Job ersetzbar sind. Immerhin möchte man ja etwas Besonderes sein und sich nicht einfach durch jemand anderen austauschen lassen. Erik Dietrich ist jedoch anderer Meinung. Er schreibt in diesem Artikel für Pluralsight, warum er glaubt, dass man sich – gerade als Softwareentwickler – sogar selbst ersetzbar machen sollte: Developers: Here’s why you should make yourself replaceable (Link: http://blog.pluralsight.com/developer-career-tips).

Seiner Meinung nach ist es nicht förderlich für die Karriere, wenn man der einzige ist, der bestimmte Aufgaben im Unternehmen lösen kann. Denn das bedeutet auch, dass man nicht von dieser Stelle weg befördert werden kann. Das gute alte Kopfmonopol ist also nicht nur für das Unternehmen schlecht (siehe Truck Factor – Agile Advice (Link: http://www.agileadvice.com/2005/05/15/agilemanagement/truck-factor/)), sondern auch für den Mitarbeiter selbst.

Erik listet noch eine Reihe weiterer Punkte auf, warum wir uns als Softwareentwickler nicht unersetzbar machen sollten. Vielleicht regt er dich ja auch zum Nachdenken an. Wie gut, dass ich mein Wissen bereits – z.B. durch diesen Blog – teile. 😉

Wie sicherst du dir deinen Job? Durch unverständlichen Code oder durch Teilen deines Wissens? Gibt es Code-Inseln, die nur du betreten darfst, oder praktiziert ihr Collective Ownership (Link: http://www.extremeprogramming.org/rules/collective.html)?

Weniger bekannte Features in Java 8

Veröffentlicht am 19.02.2016

Java 8 bietet bekanntermaßen einen Haufen toller neuer Features. Allen voran natürlich Lambda-Ausdrücke und Java 8 Streams cheat sheet | zeroturnaround.com (Link: http://zeroturnaround.com/rebellabs/java-8-streams-cheat-sheet/) (danke an Markus Amshove (Link: https://amshove.org/) für den Link). Aber mit Java 8 wurden auch einige kleine Erweiterungen an der Sprache vorgenommen, die von den großen Neuerungen überschattet werden. Benjamin Winterberg stellt in einem Artikel einige dieser nützlichen Funktionen vor: Java 8 API by Example: Strings, Numbers, Math and Files – Benjamin Winterberg (Link: http://winterbe.com/posts/2015/03/25/java8-examples-string-number-math-files/).

Ob es sich um das – lange schmerzlich vermisste – String.join(), die Vermeidung von Überläufen bei der Arithmetik oder nützliche Dateioperationen handelt, Benjamin zeigt anhand vieler praktischer Beispiele, was mit Java 8 über Lambdas und Streams hinaus noch möglich ist. Vielleicht ist ja auch für dich etwas Interessantes dabei.

Was hältst du von Java 8? Nutzt du schon die „neuen“ (naja, so richtig neu ist Java 8 nun inzwischen auch nicht mehr) Funktionen? Wird dein Code durch Lambdas und Streams wirklich „besser“?

Traumjob: Spieleentwickler!?

Veröffentlicht am 12.02.2016

Für viele Softwareentwickler, die – so wie ich selbst auch – nebenbei gerne ein wenig zocken, ist Spieleprogrammierer sicherlich ein Traumjob. Man kann an coolen Projekten arbeiten, algorithm – John Carmack’s Unusual Fast Inverse Square Root (Quake III) – Stack Overflow (Link: http://stackoverflow.com/questions/1349542/john-carmacks-unusual-fast-inverse-square-root-quake-iii), kreativ sein und quasi sein Hobby zum Beruf machen.

Allerdings hat auch die Arbeit an AAA (video game industry) – Wikipedia (Link: https://en.wikipedia.org/wiki/AAA_(video_game_industry)) ihre Schattenseiten. Letztlich ist es nämlich auch nur ein „normaler“ Job. Das beschreibt Maxime Beaudoin in seinem Artikel Why I Quit my Dream Job at Ubisoft | Gingear Studio (Link: http://gingearstudio.com/why-i-quit-my-dream-job-at-ubisoft). Er ist inzwischen als Entwickler in einem Indie-Game-Studio tätig, da der Job im „Konzern“ nicht die erhoffte Erfüllung brachte.

Die letzten beiden Spiele, die ich vor dem Start dieses zeitintensiven Blogs (durch-)gespielt habe, sind übrigens The Elder Scrolls V: Skyrim – Legendary Edition (Affiliate)* und Risen 3: Titan Lords (Affiliate)*. Ich weiß, sie sind inzwischen schon älter, aber immer noch gut 🙂

The Elder Scrolls V: Skyrim - Legendary Edition (Affiliate)* Risen 3: Titan Lords (Affiliate)*

Bist du mit deinem Job zufrieden oder träumst du auch von einer Karriere in der Spielebranche? Hast du vielleicht schon in Konzernen und „kleinen Klitschen“ gearbeitet und kannst beide Seiten verstehen? Ich freue mich über deinen Kommentar. Alternativ darfst du mir gerne ein (Rollen-)Spiel für meine ToPlay-Liste empfehlen 😉

Kommentare

  • Von Thomas Schypior (Link: https://www.youtube.com/playlist?list=PL9F90FBDCCF2640D8) am 12.02.2016
    Wärmste Empfehlung: Undertale. Dauert nur ein paar Stündchen und wird dich sicherlich mehrmals überraschen und zum Lachen bringen.
  • Von ich am 12.02.2016
    Hey, bin zwar kein Entwickler, aber habe dennoch Erfahrungen mit „kleinen Klitschen“ und großen Firmen… Meine 1. Ausbildung hab ich in einem Betrieb mit 2000 MA gemacht, mit Betriebsrat, regelmäßigen Azubiausflügen, Veranstaltungen für Azubis usw… dann holte ich mein Abi nach, studierte, brach das Studium ab und wollte was neues machen -> FISI Ausbildung. Die Ausbildung machte ich in einem Betrieb mit ca. 250 MA, ohne Betriebsrat, kein einziger Ausflug für Azubis, keine Veranstaltungen, Ausbildung eher mäßig gewesen.. ist zwar jetzt nicht soo klein wie ein 3 Mann Betrieb oder so, aber finde diese Unterschiede dennoch krass. Wurde übernommen und arbeite auch hier noch – aber wie lange, wird sich zeigen. 🙂 Achja, für deine ToPlay-Liste würde ich die definitiv die „The Witcher“ Reihe von 1 bis 3 ans Herz legen! Ist quasi ein Muss. 🙂 Greetz.

  • Von Stefan Macke am 12.02.2016
    Hallo Thomas,

    Undertale kannte ich noch gar nicht. Aber sieht auf den ersten Blick ganz witzig aus! Ich muss zugeben, dass ich noch nie ein Indie-Game ausprobiert habe. Vielleicht ist es an der Zeit. 🙂

    Viele Grüße! Stefan

  • Von Stefan Macke am 12.02.2016
    Hallo ich,

    schon interessant, wie unterschiedlich die einzelnen Unternehmen sind. In großen Unternehmen ist vielleicht grundsätzlich alles etwas professioneller aufgebaut (was aufgrund der Komplexität wohl auch so sein muss). Aber in meinem kleinen Unternehmen (auch ca. 250 Mitarbeiter) gibt es die genannten Ausflüge usw. auch. Es kommt also wohl wirklich auf das konkrete Unternehmen an. Die Größe ist nur ein Indiz für die Unternehmenskultur.

    The Witcher 3 steht (natürlich) schon auf meiner Liste! Nur leider erfüllt mein aktueller PC die Anforderungen nicht. 😉 Aber sobald ich eine neue Kiste habe, wird das ausgetestet.

    Viele Grüße! Stefan

  • Von Ani B. am 03.03.2017
    Hey, Ich habe syrim und witcher 3 gespielt… ich liebe es und auch neue Ideen schießen mir ununterbrochen in den Kopf. Ich würde gerne mein Hobby zum Beruf machen! Würdet Ihr mir bitte Typs geben wo ich am besten meine Ausbildung zum Fachinformatiker/in für Anwendungsentwicklung machen kann (am besten in Hamburg, Lüneburg oder Lübeck bzw. Umgebung) ich habe schon ein bisschen „Erfahrung“ mit java.Kara und ich möchte mir auch das Buch C++ holen. Bitte sagt mir wie ich mein größten Traum wahr machen kann.

  • Von Stefan Macke am 04.03.2017
    Hallo Ani,

    leider habe ich keine Kontakte in Richtung Spieleentwicklung. Da kann ich dir nicht weiterhelfen :-/

    Viele Grüße! Stefan

  • Von Lycea am 15.03.2017
    Hi, seid ich mit meiner Ausbildung ( Anwendungsentwicklerin) vor knapp 3 Jahren bald angefangen habe träume ich auch davon Spiele zu entwickeln denn in meiner Freizeit auch vieles immer gespielt habe. Ebenso habe ich dann nun selber meinen Traum angefangen zu verwirklichen in dem ich in meiner Freizeit Spiele programmiere entweder wie in meiner Ausbildung mit C/C++ oder auch mit Lua und dem löve Framework. Es währe schön wenn ich einmal hautnah dabei sein könnte. Aber sonst werde ich es als persönliches Projekt vortführen und villeicht irgendwann auch veröffentlichen open source oder anders. Ich habe in beidem schon gearbeitet während meiner Ausbildung da ich einer kleinen Firma ( <50) eingestiegen bin und dann die Firma von einer sehr sehr großen aufgekauft wurde. Ich würde sagen es hat beides seine vor und Nachteile. In kleineren Firmen ist das Klima einfach toll und man kennt jeden. Bei größeren hat man aber viele viele Möglichkeiten und auch ein gutes Image wenn man sich je woanders bewerben möchte + eine gewisse Sicherheit. Mfg

  • Von Stefan Macke am 15.03.2017
    Hallo Lycea,

    danke für den Erfahrungsbericht! Ich drücke dir die Daumen, dass es irgendwann einmal mit deinem Traum klappt! 🙂

    Viele Grüße! Stefan

  • Von Marcel (Link: https://lord-thrawn.elite-gamer.biz) am 24.10.2017
    Gibt es den Buchenpfehlungen für C / c++ wo man auch das lernen kann?

  • Von Stefan Macke am 26.10.2017
    Von mir leider nicht. Damit kenne ich mich so gar nicht aus…

Die häufigsten Anfängerfehler bei der Java-Programmierung

Veröffentlicht am 05.02.2016

Über einen Artikel bei JAXenter (Java-Programmierung: Die 10 häufigsten Anfängerfehler – JAXenter (Link: https://jaxenter.de/java-programmierung-anfaengerfehler-33953)) bin ich auf diesen Blog-Post gestoßen: Ask a Swiss: Beginners‘ 10 most common Java programming mistakes revealed by Big Data (Link: http://www.askaswiss.com/2016/01/most-common-java-mistakes-revealed-by-big-data.html).

Forscher der University of Kent haben unfassbare 46 Millionen Quelltext-Dateien aus dem BlueJ Blackbox Data Collection Project (Link: http://www.bluej.org/blackbox.html) auf Compiler-Fehler untersucht und die häufigsten Anfängerfehler bei der Programmierung mit Java ermittelt.

Die Liste enthält „Klassiker“ wie = vs. == oder == zum String-Vergleich. Aber auch – zumindest für mich – überraschende Einträge wie fehlerhafte Klammersetzung (z.B. (]) oder die unvollständige Implementierung von Interfaces.

Für mich ist die Liste hochinteressant, da ich selbst Programmierkurse gebe und mich teilweise nicht mehr in die Denkweise der Lernenden hineinversetzen kann. Daher ist es sinnvoll, noch einmal aufgezeigt zu bekommen, welches Fehlerpotential in den für mich selbstverständlichen Quelltext-Beispielen steckt.

Was waren deine häufigsten Anfängerfehler bei der Programmierung? Hast du vielleicht heute noch einen Fehler, der dich immer mal wieder ärgert?

Git-Tipps für Fortgeschrittene (aber auch Anfänger)

Veröffentlicht am 29.01.2016

Dieser Artikel von Andy Jeffries ist meine Standardempfehlung für eine Einführung in Git: 25 Tips for Intermediate Git Users (Link: https://www.andyjeffries.co.uk/25-tips-for-intermediate-git-users/). Obwohl Andy ihn 2009 für fortgeschrittene Benutzer von Git geschrieben hat, würde ich sagen, dass die genannten Befehle heute zum Standardrepertoire jedes Softwareentwicklers (der mit Git arbeitet) gehören sollten.

Der Artikel gibt eine kurze und prägnante Einführung in die Funktionsweise von Git (siehe Gerichteter Graph – Wikipedia (Link: https://de.wikipedia.org/wiki/Gerichteter_Graph)), geht auf alltägliche Probleme wie Merge-Konflikte ein und zeigt auch einige nicht ganz so häufig verwendete Befehle (zumindest meiner Meinung nach) wie git rebase -i.

Wer also nicht gleich das – auch sehr zu empfehlende – Scott Chacon – Pro Git (Affiliate)* (Pro Git (Link: https://git-scm.com/book/de/v1)) lesen möchte, dem kann ich den Artikel wärmstens empfehlen.

Scott Chacon - Pro Git (Affiliate)*

Nutzt du Git für die Versionsverwaltung? Was hältst du von dem Artikel oder/und dem Buch? Hast du noch weitere Ressourcen zu Git? Dann schreib mir gerne einen Kommentar.

Der Eid des Programmierers

Veröffentlicht am 22.01.2016

Uncle Bob (Robert C. Martin) hat vor Kurzem seinen „Programmierer-Eid“ veröffentlicht: The Programmer’s Oath – Clean Coder Blog (Link: http://blog.cleancoder.com/uncle-bob/2015/11/18/TheProgrammersOath.html).

Darin stellt er einige Selbstverpflichtungen auf, denen ein professioneller Softwareentwickler Folge leisten sollte. Es handelt sich um viele Best Practices, die ich so auch meinen Azubis und Studenten vermitteln würde. Beispiele:

  • Ich werde häufig kleine Releases erstellen, damit ich nicht den Fortschritt anderer Entwickler behindere.
  • Ich werde mutig und schonungslos den Code bei jeder Gelegenheit optimieren. Ich werde niemals Code schlechter machen.
  • Ich werde niemals aufhören zu lernen und mein Handwerk zu verbessern.

Ich finde die Idee eines Programmierer-Eids sehr spannend und die Inhalte äußerst praxisbezogen und sinnvoll. Viele Empfehlungen (wie z.B. die The Boy Scout Rule – Programmer 97-things (Link: http://programmer.97things.oreilly.com/wiki/index.php/The_Boy_Scout_Rule) aus dem zweiten Punkt) basieren wohl auch auf Erkenntnissen aus Robert C. Martin – Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*, der Programmiererbibel, die ich als absolutes Pflichtprogramm für jeden Azubi empfehle. Wenn du also die obigen Punkte noch vertiefen willst, dann schau doch mal rein.

Robert C. Martin - Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*

Was hältst du von Uncle Bobs Eid? Befolgst du ihn vielleicht sogar schon (unabsichtlich) bei deiner Arbeit?

Kommentare

  • Von Buzz Tyca am 24.01.2016
    Hallo Stefan, heute möchte ich nicht deinen Blog oder deinen Podcast kommentieren, sondern meinen herzlichen Dank aussprechen. Ich habe in dieser Woche erfolgreich meine mündliche Prüfung zum FIAE absolviert und somit meine Umschulung abgeschlossen. In der Vorbereitung auf die Prüfungen habe ich immer wieder deinen Blog gelesen und vor allem deine Podcasts gehört. Beides hat mir sehr geholfen. Ich konnte mich mit deiner Hilfe bestens auf die Prüfung vorbereiten. Ich kann nur jedem Raten zumindest einen Blick zu riskieren. Sicherlich hat jeder seine eigene Art und Weise zu lernen und man muss natürlich noch mehr als genug selbst tun, aber es kann nicht schaden. Ich werde auch weiterhin deine Beiträge verfolgen und freue mich nun auf einen hoffentlich erfolgreichen Einstieg in mein Berufsleben als Fachinformatiker und verbleibe bis dahin mit Dank und lieben Grüßen Buzz Tyca

  • Von Stefan Macke am 24.01.2016
    Hallo Buzz Tyca,

    vielen Dank für dein Feedback. Freut mich, dass ich helfen konnte! Und herzlichen Glückwunsch zur bestandenen Prüfung!

    Ich wünsche dir viel Erfolg beim Einstieg ins Berufsleben als Entwickler. Was kann es besseres geben als den ganzen Tag zu programmieren? 😉

    Viele Grüße! Stefan

Expertentipps zur Gestaltung von Präsentationen

Veröffentlicht am 15.01.2016

Ich reite ja immer wieder auf den „klassischen“ IHK-Präsentationen rum (die mit Die Agenda muss auf jeder Folie stehen – Mythen der Projektpräsentation, Corporate Design ist Pflicht – Mythen der Projektpräsentation und möglichst Technische Inhalte kann man nicht mit Bildern illustrieren – Mythen der Projektpräsentation). Und heute habe ich mal eine Linkempfehlung, die in die gleiche Richtung geht: 10 tips for better slide decks | TED Blog (Link: http://blog.ted.com/10-tips-for-better-slide-decks/).

Der Beitrag des Lead Designers von TED: Ideas worth spreading (Link: http://www.ted.com/) ist vollgestopft mit guten Tipps, die nicht nur für die weltberühmten TED-Präsentationen gelten, sondern genauso für jegliche andere Präsentation – inkl. der IHK-Abschlusspräsentation.

Es gibt nicht nur „high-level“ Tipps, sondern auch konkrete Hinweise wie z.B. zur Gestaltung von Diagrammen oder dem Hervorheben von Bildteilen. Trotzdem ist der Artikel recht kurz und gut zu lesen.

Update: Mein Leser Karsten hat mir noch diesen Artikel geschickt, den ich direkt mal weiterempfehle: 10 Tipps, um mit Präsentationen zu überzeugen | Gründerszene (Link: http://www.gruenderszene.de/marketing/prasentationen-10-tipps). Dort werden auch konkrete Tipps für den beruflichen Alltag genannt.

Ich – als IHK-Prüfer – würde mich freuen, wenn mehr Prüflinge die genannten Tipps beherzigen würden. Das würde mir die langen Prüfungstage etwas erträglicher machen! 😉

Was hältst du von den Präsentationstipps? War noch etwas Neues für dich dabei? Was würdest du anders machen?

Kommentare

  • Von Michael am 15.01.2016
    Hallo Stefan, erst vor kurzem bin ich (seit Jahren wieder) auf TED aufmerksam geworden. Und mir fiel direkt auf, was man noch alles für eigene Präsentationen mitnehmen kann, wenn man einfach mal ein bisschen stöbert. Die Präsentationen sind wirklich gut. Der 7. Tipp ist meiner Meinung nach sehr gut. Das ist zwar leider mit das Aufwändigste, selbst wenn man es nur mit Powerpoint-Kreisen macht, die man verschiebt, aber das macht so einen großen Unterschied aus. Ein Bild wie im 8. Tipp habe ich allerdings noch nie durchlaufen lassen. Vermutlich hatte ich einfach noch nie das richtige Bild für so einen Zweck, haha. Als Erweiterung zum letzten Tipp hätte ich noch, auch Formeln zu vereinfachen. In meiner Amortisationrechnung haben sich die Einheiten gegenseitig rausgekürzt, aber sie standen in der Formel. Ich habe überall das „pro Monat“ und „pro Stunde“ entfernt und sage einfach, dass sich die Werte auf einen Monat, respektive eine Stunde beziehen, sodass ich nur noch die Euronen in der Formel habe und halt ganz zufällig am Ende wieder Monate erhalte. Tabellen natürlich genauso. Ich glaube Markus war es, der in seinen Tabellen die Neben- und Lohnkosten in der Präsentation direkt zusammengefasst hat. Das habe ich jetzt so auch gemacht, weil es in dem Moment niemanden wirklich interessiert, wie die Werte genau aussehen, solange ich einfach sagen, dass sie darin enthalten sind. Das größte Problem mit den meisten guten Tipps ist nur leider, dass man Zeit für deren Umsetzung benötigt. Meine persönliche Einstellung ist allerdings, dass diese Abschlusspräsentation die beste Präsentation werden sollte, die ich jemals geschaffen habe und die ich mit meinem momentanen Können schaffen kann. Denn wenn nicht jetzt, wann dann? Nur so wird man auch in der Zukunft besser darin und schüttelt irgendwann gute Präsentationen aus dem Ärmel: „Ist-Analyse und Soll-Konzept auf einer Folie mit zwei Listen? Mach doch noch Kästen drum und mal einen Pfeil dazwischen: Sieht direkt besser aus.“ Was außerdem etwas schlimm ist und schöne Ideen hemmt, sind Außenstehende, die in einem Konzept nicht das Potenzial sehen, das man selbst sieht, und stattdessen direkt alles zerreißen. Ich hatte auf einer Folie weit am Anfang drei Puzzleteile (drei Ecken eines Quadrates) mit jeweils einem Wort darin. Einfach in der Ecke der Folie ohne irgendwelches Design. Fanden alle blöd. Meine umgesetzte Idee: In den Puzzleteilen sind Bilder. In zwei Teilen sind bereits implementierte Teile einer Software. Das dritte Teil fliegt rein und zeigt den geplanten Teil. Am Ende der Präsentation zeige ich das Puzzle nochmals mit einem vierten Teil ohne Bild: Das Projekt hat Zukunft. Zugegeben: Ein paar Gimp-Küste sind mir bei den Bildern hilfreich gewesen, aber auch so finden viele Kollegen die Idee jetzt doch relativ gut. Mit freundlichen Grüßen Michael

  • Von Stefan Macke am 16.01.2016
    Hallo Michael,

    ich gebe dir absolut recht: eine gute Präsentation erfordert Zeit. Dessen sind sich wohl viele Prüflinge nicht bewusst. Meine eigenen Studenten hatten gerade eine Woche vor der Prüfung zum ersten Mal eine Probepräsentation. Das ist viel zu wenig Zeit, um noch Optimierungen umzusetzen. Ich kann nur allen Prüflingen raten, sofort nach Abgabe der Projektdokumentation mit der Präsentation zu beginnen. Immerhin macht sie 25% der Note der mündlichen Prüfung aus.

    Ich drücke dir beide Daumen für deine Prüfung. Ich hoffe, dass die Prüfer dein Engagement und deinen Mut zu neuen Präsentationsformen „sehr gut“ bewerten. 🙂

    Viele Grüße! Stefan

  • Von Sebastian am 17.01.2016
    Hallo Stefan, einer aus meiner Klasse will für die Präsentation Prezi verwenden. Da das ja etwas nicht gerade alltägliches für eine IHK-Präsentation ist, wollte ich fragen ob Prüfer eher die Konservative Präsentationen bevorzugen oder ob sie etwas „exotisches“ auch interessant fänden. Kann man mit solchen Ausreißern dann punkten oder hängt das eher dann vom Geschmack der Prüfer ab wie sie so einen Exoten finden? Gruß Sebastian

  • Von Stefan Macke am 17.01.2016
    Hallo Sebastian,

    ich habe selbst schon einige Präsentationen mit Prezi gesehen. Es ist also nicht mehr hip genug, um Prüfer hinterm Ofen hervorzulocken 😉 Einige Kollegen fanden Prezi toll, anderen ging das ständige Rein- und Rausgezoome auf die Nerven. Ich persönlich gehöre eher zu letzterer Gruppe. Denn die ultracoolen Animationen sehen zwar hübsch aus, lenken aber nach dem dritten Mal vom Inhalt ab. Und genau um den geht es bei der Präsentation.

    Das Problem bei deiner Frage ist nämlich, dass das Tool völlig irrelevant ist. Man kann sowohl mit PowerPoint als auch mit Keynote oder eben Prezi schlechte Präsentationen bauen. Es kommt immer auf den Inhalt an und nicht (nur) auf die Gestaltung oder das Werkzeug. Wenn die wichtigen Inhalte (technisch und wirtschaftlich) gut rüberkommen, ist völlig egal, ob Prezi eingesetzt wurde oder nicht. Niemand wird einem Prüfling für Prezi eine bessere Note geben. Oder anders gesagt: Prezi ist kein Garant für eine gute Note (aber genauso wenig für eine schlechte). Wenn der Vortragende stocksteif neben der Leinwand steht, helfen auch tolle Animationen nicht.

    Nicht falsch verstehen: Ich bin ein Freund von Animationen. Sofern sie den Inhalt unterstützen. Man kann z.B. unwichtige Teile von Diagrammen ausblenden oder in eine Entität im ERM reinzoomen. Aber wenn jeder Satz drehend reingeflogen kommt, ist das Ziel verfehlt.

    Also kurz zusammengefasst: Prezi ist ein tolles Werkzeug, wenn man es verwendet, um den Inhalt bestmöglich zu transportieren. Wenn man es einsetzt, um von den mangelnden Präsentationsfähigkeiten abzulenken, ist es genauso gut oder schlecht wie jedes andere Werkzeug.

    Viele Grüße! Stefan

  • Von Ulf am 21.01.2016
    Hallo Stefan, ich stand vor der Wahl Prezi oder PowerPoint zu nutzen und habe mich letzten Endes für PowerPoint entschieden. Ich habe während der Ausbildung in der Schule eine Präsentation mit Prezi gehalten und dort festgestellt das Prezi ein wenig zu „verspielt“ ist. Dieses ganze Gezoome ist am Anfang wirklich lustig aber passt, imho, nicht wirklich zu einer technischen Präsentation. Als Webdesigner würde ich wahrscheinlich wieder auf Prezi zurück greifen da dort mit Sicherheit die Möglichkeiten der Interaktivität wesentlich umfangreicher sind als bei z.B. PowerPoint und das „ClickieBuntie“ da auch einen gewissen Charme entwickelt. Bei einer FIAE Präsentation bin ich aber der Meinung muss der Fokus klar auf der technischen Seite liegen und dort brauche ich kein ClickieBuntie sondern eine klar strukturierte Präsentation in der „MEINE“ Leistung klar herausgestellt wird und zeigt wie toll doch das Programm ist was ich geschrieben habe und was man damit z.B. an Kosten einsparen kann. 1-7-7 Folien <3 Es kommt ja auch immer wieder die Quellcodediskussion auf. In meinem Prüfungsausschuss wurde klar gesagt, dass von mir als AE erwartet wird, Quellcode zu zeigen. Ich habe mich lange dagegen gewehrt aber letztendlich habe ich, auch hinsichtlich dem Fachgespräch, Quellcode in meine Präsentation eingebaut, den Code dabei aber so kurz wie möglich gehalten und nur die pregnantesten Stellen kurz angesprochen. Kein Prüfer kann in der Kürze der Zeit das verstehen was ich mir da „zurechtgeklempnert“ habe. Ich habe auch mehr Quellcode in meine Präsentation eingebaut als ich während des Vortrags zeige, um bei Nachfragen im Fachgespräch in der Lage zu sein eventuelle Nachfragen a la „Aber warum haben sie denn nicht noch mehr Quellcode gezeigt?“ direkt erschlagen zu können. Zu den 15 Minuten Zeit: Während meiner Proben habe ich immer so um 16-17 Minuten gebraucht und wenn man dann die Nervosität am Prüfungstag einkalkuliert wird man in der Regel bei knapp 15 Minuten rauskommen. Man schafft es einfach nicht, nicht nervös zu sein und wird so in der Regel zu schnell zu sprechen. Ich habe mich in meiner Präsentation dafür entschieden, meine Agenda immer wieder mit dem aktuellen Punkt einzublenden. Das mache ich nicht nur für die Zuhörer damit die wissen wann das Grauen endlich ein Ende hat, sondern auch für mich als Bremse. Wenn eine Agendafolie kommt dann halte ich kurz Inne, atme ein-/zweimal tief ein und aus und mache dann erst weiter. So kann sich dann auch der Zuhörer orientieren und ist dann wieder bei mir. Ich kann die Zeit auch mit einem gut formulierten Überleitungssatz überbrücken, aber da verlässt einen schnell die Erinnerung und es besteht die Gefahr sich zu verhaspeln. Eine lustige Anekdote am Anfang der Präsentation lockert auch noch mal die Atmosphäre auf und gibt einem noch Selbstsicherheit. Ich würde auch den Ablauf der Präsentation aufeinander aufbauen lassen. Anders als in vielen anderen Präsentationen die ich während meiner Recherchen zum Thema: „Wie präsentiere ich die von mir programmierte Technische Software ansprechend und nicht Furz trocken?“ gesehen habe, bin ich hingegangen und habe die wirtschaftliche Betrachtung vor das letzte Kapitel gepackt. Somit konnte ich kurz vor dem Ende den Zuhörern noch einmal veranschaulichen, was mein Programm in der Lage ist zu leisten und das auch noch an Zahlen fest machen. Ich würde auch nicht hingehen und eine Amortisationsdauer des Projektes präsentieren. Viel besser ist es zu zeigen, was mein Programm z.B. an Zeitersparnis bringt. Warum nicht die Amortisation? Nun, die internen und dem Kunden in Rechnung gestellten Kosten für die Entwicklung sind von Firma zu Firma stark unterschiedlich. Wenn ich aber hingehe und einfach nur eingesparte Stunden aufzeige, dann rechnet jeder der Prüfer im Kopf durch, was dort an Geld gespart werden kann und zwar mit ihm vertrauten Werten aus seiner Firma. Amortisation in die Dokumentation aber nicht in die Präsentation. In der Präsentation muss so ein Totschlagargument wie „Wir brauchen für die gleiche Arbeit nur noch 1/5 der Zeit“ und nicht „Das Projekt hat die Kosten nach 2 Jahren wieder reingeholt und wirft ab dann Gewinn ab.“ kommen. Da darf man dann denke ich auch ein wenig die SalesDramaQueen raushängen lassen. Dann hab ich auch wieder die Prüfer am Wickel und kann dann in Ruhe auf Future Features eingehen. So Sachen bleiben dann auch den Prüfern im Gedächtnis. Ich will doch kurz vor dem Ende den Prüfern noch einmal mitteilen wie toll mein Programm ist, damit der das im Hinterkopf hat wenn er die Präsentation während der Notenbesprechung noch einmal reflektiert. I’m so sorry for this.WoT 😉 Gruß Ulf

  • Von Stefan Macke am 21.01.2016
    Hallo Ulf,

    wow, danke für dein umfangreiches Feedback!

    dort brauche ich kein ClickieBuntie sondern eine klar strukturierte Präsentation in der „MEINE“ Leistung klar herausgestellt wird

    Naja, man kann auch „harte“ Fakten ansprechend darstellen. ClickieBuntie vertrete ich auch nicht. Es geht um eine optimale Präsentation der Inhalte. Und das ist – meiner Meinung nach – nie eine langweilige Textwüste. Du kannst z.B. einfach ein Klassendiagramm zeigen anstatt eines Textes. Oder Screenshots anstatt einer Featureliste. Oder ein Use-Case-Diagramm anstatt der Anforderungen.

    Zum Thema Quellcode habe ich hier schonmal was geschrieben: Sourcecode gehört nicht in die Präsentation – Mythen der Projektpräsentation. Meine Empfehlung: Auf jeden Fall zeigen!

    Zur Amortisation: Warum nicht beides zeigen, also eingesparte Zeit und Amortisationsdauer? Nur zusammen ergibt sich ein stimmiges Bild. Kann ja sein, dass dein Programm 10 Stunden Arbeit einspart, aber im Vergleich zu den 70 Stunden Projektarbeit ist das dann halt ziemlich wenig. Außer die Stunden kosten dein Unternehmen jeweils 200 Euro. Das weiß aber niemand. Ich empfehle daher, die Amortisation zu zeigen und auch zu begründen wie sie zustande kommt, also die eingesparte Zeit, Kosten usw.

    Viele Grüße! Stefan

Innovationen in Legacy-Systemen

Veröffentlicht am 18.12.2015

In einer recht aktuellen Episode des Software-Engineering-Radios wird Dave Thomas (Link: http://www.davethomas.net/) (nein, nicht der Dave Thomas (Pragmatic Programmers) (Link: http://pragdave.me/), der Andy Hunt und Dave Thomas – The Pragmatic Programmer. From Journeyman to Master (Affiliate)* geschrieben hat) zum Thema Innovationen in Legacy-Systemen interviewt: SE-Radio Episode 242: Dave Thomas on Innovating Legacy Systems : Software Engineering Radio (Link: http://www.se-radio.net/2015/11/se-radio-episode-242-dave-thomas-on-innovating-legacy-systems/).

Da ich in meiner täglichen Arbeit – wie viele andere Softwareentwickler sicherlich auch – mit Legacy-Software zu tun habe (siehe auch Wie man jeden Code in jedem System testbar macht), fand ich die Podcast-Episode sehr spannend. Dave vertritt auch ein paar kontroverse Ansichten. So ist er z.B. der Meinung, dass Unit-Tests Zeitverschwendung sind oder dass er lieber in einer Legacy-Anwendung in COBOL – Wikipedia (Link: https://de.wikipedia.org/wiki/COBOL) arbeiten würde als in einer in Java. Gerade letztere Aussage finde ich natürlich spannend, da wir unsere zentrale Anwendung mit Natural (Link: http://www.softwareag.com/corporate/products/adabas_natural/natural/overview/default.asp) entwickeln, das COBOL sehr ähnlich ist.

In diesem Artikel kann man ein wenig Natural-Code sehen: Avoid Redundancy! – Lessons Learned from SOA-fying a Monolith | SOA rocks! (Link: http://serviceorientedarchitect.com/avoid-redundancy-lessons-learned-from-soa-fying-a-monolith/). Unsere „Innovation“ im Natural-Umfeld ist die Entwicklung einer Domänenspezifische Sprache – Wikipedia (Link: https://de.wikipedia.org/wiki/Dom%C3%A4nenspezifische_Sprache), mit der wir Natural-Code generieren können. Dadurch können wir abstraktere Konzepte einsetzen, müssen weniger Code schreiben und sind auch noch deutlich produktiver, weil viel Fleißarbeit wegfällt. Außerdem haben wir NatUnit – A Unit Test Framework for Software AG Natural (Link: http://www.sourceforge.com/p/natunit) entwickelt.

Man kann also durchaus auch in „alten“ Systemen und Programmiersprachen moderne Konzepte umsetzen. Es ist alles nur eine Frage der Einstellung der Entwickler!

Welche Innovationen kennst du aus dem Umfeld von Legacy-Anwendungen? Hast du vielleicht selbst schon innovative Konzepte oder Ideen in eine Altanwendung eingebracht?

Wie man jeden Code in jedem System testbar macht

Veröffentlicht am 11.12.2015

In diesem bereits etwas älteren Artikel schildert Rico Mariani ein 5-Schritte-Programm, um jeden Code in jedem System testbar zu machen: How to make ANY code in ANY system unit-test-friendly – Rico Mariani’s Performance Tidbits – Site Home – MSDN Blogs (Link: http://blogs.msdn.com/b/ricom/archive/2014/11/20/how-to-make-any-code-in-any-system-unit-test-friendly.aspx).

Rico zeigt, wie er Schritt für Schritt Legacy-Code (Working Effectively with Legacy Code (Link: http://www.objectmentor.com/resources/articles/WorkingEffectivelyWithLegacyCode.pdf)) unter Tests bringt. Das ist sicherlich für viele Entwickler ein interessantes Vorgehen, da die Mehrzahl da draußen wahrscheinlich häufiger bestehenden Code wartet als tatsächlich neuen schreibt (vgl. auch I’m doing 90% maintenance and 10% development, is this normal? – Programmers Stack Exchange (Link: http://programmers.stackexchange.com/questions/152464/im-doing-90-maintenance-and-10-development-is-this-normal)).

Ich finde das Vorgehen gut nachvollziehbar und gefahrlos anwendbar, da alle Aktionen potentiell auch von einer IDE automatisch durchgeführt werden könnten. Quasi eine Kurzversion von Michael Feathers‘ hervorragendem Buch Michael Feathers – Working Effectively with Legacy Code (Robert C. Martin Series) (Affiliate)*. Das Buch kann ich übrigens auch jedem Softwareentwickler empfehlen, der sich mit einer großen Menge an ungetestetem Code konfrontiert sieht!

Michael Feathers - Working Effectively with Legacy Code (Robert C. Martin Series) (Affiliate)*

Wie häufig schlägst du dich mit „altem“, ungetestetem Code herum? Betreibst du den nötigen Aufwand, um den Code vor der Überarbeitung unter Test zu stellen?

Was wir von Haskell lernen können

Veröffentlicht am 04.12.2015

In einem interessanten Vortrag bei der NDC Oslo (Link: http://ndcoslo.com/) zeigt Blog von Venkat Subramaniam (Link: http://blog.agiledeveloper.com/), was wir von Haskell (Link: https://www.haskell.org/) lernen können: Learning from Haskell – Venkat Subramaniam (Link: https://vimeo.com/131409651).

Venkat vergleicht einige Programmierschnipsel in C# mit Haskell und zieht Schlüsse, in welchen Bereichen Haskell (oder andere funktionale Programmiersprachen) den gängigen Programmiersprachen wie C# und Java voraus sind. Aber er gibt auch Anregungen, wie man die Lehren daraus in seinem eigenen Code umsetzen kann. Unter anderem behandelt er diese Themen:

  • Warum sollte man sich überhaupt eine andere Programmiersprache anschauen?
  • Statische Typisierung muss nicht nervig sein.
  • Die Sprache sollte für uns arbeiten und nicht umgekehrt.
  • Expressions sind besser als Statements.

Außerdem ist Venkats Präsentationsstil wie immer erfrischend und mit lustigen Seitenhieben auf Programmierer gespickt. Daher eine klare Anschauempfehlung von mir! 🙂

Hast du schon einmal mit einer „echten“ funktionalen Programmiersprache wie Haskell gearbeitet? Was hast du dabei gelernt? Konntest du die Lehren auf deine tägliche Programmierarbeit übertragen?

Kommentare

  • Von Robin Schneider (Link: https://github.com/ypid) am 10.12.2015
    Hallo Stefan, Bei Haskell bin ich noch nicht so richtig auf den Geschmack gekommen und wie im Vortrag erwähnt, sieht die Sprache auf den ersten Blick ja auch völlig anders aus (verglichen mit den üblichen Verdächtigen wie C++, Java, Python, JavaScript (Link: https://www.youtube.com/watch?v=FqhZZNUyVFM)). Es gibt Leute wie Joey Hess (Link: https://joeyh.name/) die auf Haskell schwören und so nette Programme wie git-annex (Link: https://git-annex.branchable.com/) und github-backup (Link: https://github.com/joeyh/github-backup) in Haskell schreiben. Es muss also was dran sein an diesem Haskell :). Ich bin auch mal, ohne es zu ahnen, in einen Vortrag (Link: http://www.tuebix.org/programm/grimm-cpp_funktional/) geraten, der, anderes als es der Titel vermuten ließ, eigentlich Werbung für Haskell war 🙂 Typableitung ist schon eine feine Sache. Ich als FISI bin ja beruflich mehr der Skripter und damit in dynamisch typisierten Sprachen unterwegs, habe aber vor Kurzem angefangen in Haxe (Link: http://haxe.org/) zu schreiben (wo du schon auf nicht so populäre Sprachen wie Haskell eingehst 🙂 ). Das schöne an Haxe ist, dass man seinen Code einmal schreiben kann und dann für andere Sprachen/Plattformen übersetzen kann (inklusive Unit-Tests, die dann ebenfalls in die Zielsprache übersetzt werden und in dieser ausgeführt werden). Das funktioniert auch erstaunlich gut (siehe suncalc (Link: https://github.com/ypid/suncalc)). Hintergrund bei mir ist, dass ich eine Bibliothek für Öffnungszeiten schreibe und diese gerne irgendwann nativ auf anderen Plattformen (Link: https://github.com/opening-hours/opening_hours.js/issues/136) wie Android hätte. Ich denke auch, dass man von funktionalen Sprachen wie Haskell einiges in andere Sprachen mitnehmen kann. Funktionen wie map oder Ähnliches gibt es ja in den meisten Sprachen.

  • Von Stefan Macke am 10.12.2015
    Hallo Robin,

    ich habe Haskell auch noch nicht selbst eingesetzt, aber die Features sind schon ziemlich cool 🙂 Haxe kannte ich noch nicht. Sieht ja spannend aus. Wobei ich da irgendwie Bedenken hätte, dass es die Plattform nächstes Jahr noch gibt. Aber ich kann auch nicht einschätzen, wie stark die Community dahinter ist.

    Viele Grüße! Stefan

Die schlechtesten Sprachfeatures von C

Veröffentlicht am 27.11.2015

Vor einiger Zeit bin ich auf einen interessanten Artikel von Fabulous adventures in coding | Eric Lippert’s blog (Link: http://ericlippert.com/) gestoßen, der lange am C#-Compiler mitgearbeitet hat. Er schildert die aus seiner Sicht 10 schlechtesten Features von C#: Sharp Regrets: Top 10 Worst C# Features | | InformIT (Link: http://www.informit.com/articles/article.aspx?p=2425867).

Spannend zu lesen, was er als Sprachdesigner anders gemacht hätte. Er geht auf Dinge wie den Bitweiser Operator – Wikipedia (Link: https://de.wikipedia.org/wiki/Bitweiser_Operator#Verschiebeoperatoren_in_Programmiersprachen), die Reihenfolge von Datentyp und Name bei der Deklaration von Variablen und – mein Lieblingsthema (auf Platz 1) – Anwendungsentwickler-Podcast #13: Häufige Fragen im Fachgespräch – Programmierung (Teil 2) | Fachinformatiker Anwendungsentwicklung ein.

Ich muss sagen, dass ich die meisten der genannten Features in der Praxis kaum oder gar nicht benutze, aber es ist immer schön zu sehen, dass auch moderne Programmiersprachen rückblickend anders entwickelt worden wären. Und warum sollte es den Sprachdesignern auch anders gehen als uns normalen Entwicklern? 😉

Has(s)t du auch einige schlechte Sprachkonstrukte in deiner Programmiersprache? Welche Features sind besonders nervig?

Der schlimmste Fehler in der Informatik

Veröffentlicht am 13.11.2015

Passend zum heutigen Freitag den 13. habe ich einen sehr guten Artikel zum gruseligsten Fehler in der Informatik gefunden: The worst mistake of computer science – Lucidchart (Link: https://www.lucidchart.com/techblog/2015/08/31/the-worst-mistake-of-computer-science/).

Der Fehler ist das Konzept von null. null macht immer Probleme und löst fast nie welche. Der Artikel bei Lucidchart zeigt verschiedenste Unzulänglichkeiten von null auf und zeigt am Ende auch mögliche Alternativen, wie z.B. Optional (vgl. Optional (Java Platform SE 8 ) (Link: https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)). Außerdem mag ich die Übersicht mehrerer Programmiersprachen und ihres NULL Scores 🙂

Also: Lest den Artikel aufmerksam durch, vermeidet null und tut alles gegen die allseits verhasste NullPointerException! Eure Kollegen (und auch euer zukünftiges Ich) werden es euch danken!

Welche interessanten Erfahrungen habt ihr schon mit null gemacht? Wie lange dauerte eure längste Suche nach der Ursache einer NullPointerException? 😉

Live-Evaluierung von Code während der Programmierung

Veröffentlicht am 20.11.2015

Von Blog von Markus Amshove (Link: https://amshove.org/) habe ich vor Kurzem einen Hinweis auf dieses spannende Video bekommen: Visual Studio: Alive – See what your code does as your write it! – YouTube (Link: https://www.youtube.com/watch?v=X3QdjdKFfPQ&feature=youtu.be). Dort werden die unglaublichen Features von Alive für Visual Studio (Link: https://comealive.io/) gezeigt. Das muss man gesehen haben, um es zu glauben! Ich kenne jedenfalls kein anderes Tool, das solche Möglichkeiten hat.

Mit Alive wird der Code, den man programmiert, nämlich schon während der Programmierung evaluiert und die Werte von Variablen werden direkt inline angezeigt. Das macht es deutlich einfacher, den Code zu verstehen. Bei for-Schleifen gibt es sogar kleine Slider, um den Wertebereich durchzuspielen, und alle abhängigen Werte werden direkt aktualisiert. Das ist schon eine echt coole Sache!

Ganz neu war mir die Idee allerdings nicht, da Bret Victor etwas Ähnliches bereits vor einigen Jahren im Bereich JavaScript vorgestellt hat: Bret Victor – Inventing on Principle auf Vimeo (Link: https://vimeo.com/36579366). Auch dieses Video kann ich absolut empfehlen, wenn man mal wirklich coole Programmierung sehen will und wieder Lust aufs Programmieren bekommen möchte 🙂

Bret Victor – Inventing on Principle (Link: https://vimeo.com/36579366) from CUSEC (Link: https://vimeo.com/cusec) on Vimeo (Link: https://vimeo.com).

Habt ihr noch Tipps für „coole“ Videos zum Programmieren? Oder kennt ihr Tools, die solche innovativen Konzepte umsetzen? Ich würde mich über Kommentare freuen.

Verkürzung der Ausbildung

Veröffentlicht am 30.10.2015

Eigentlich wollte ich zum Thema Ausbildungszeitverkürzung einen eigenen Blog-Artikel schreiben. Aber als ich bei der Recherche gesehen habe, welche Sonderfälle und Ausnahmen es so gibt, habe ich es mir doch anders überlegt. Das Thema wurde nämlich bereits an anderer Stelle gründlich behandelt.

Grundsätzlich befassen sich zunächst einmal die folgenden Paragraphen des Berufsbildungsgesetz (Link: http://www.gesetze-im-internet.de/bbig_2005/) mit dem Thema Ausbildungsverkürzung:

  • § 7 Anrechnung beruflicher Vorbildung auf die Ausbildungszeit (BBiG) (Link: http://www.gesetze-im-internet.de/bbig_2005/__7.html)
  • § 8 Abkürzung und Verlängerung der Ausbildungszeit (BBiG) (Link: http://www.gesetze-im-internet.de/bbig_2005/__8.html)
  • § 45 Zulassung in besonderen Fällen (BBiG) (Link: http://www.gesetze-im-internet.de/bbig_2005/__45.html)

Für einen guten Überblick kann ich diesen Artikel bei AZUBIYO empfehlen, der alle möglichen Fälle und Regelungen abdeckt und gut verständlich ist: Ausbildungsverkürzung – Wann kann ich verkürzen? | AZUBIYO (Link: http://www.azubiyo.de/ausbildung/ausbildungsverkuerzung/)

Aber auch die IHK Oldenburg, für die ich selbst prüfe, hat eine hervorragende Übersicht zusammengestellt: Ausbildungszeit verkürzen und verlängern – Oldenburgische Industrie- und Handelskammer (Link: http://www.ihk-oldenburg.de/aus-_und_weiterbildung/ausbildung/unternehmen/wissenswertes_regeln_und_tipps/ausbildungszeit_verkuerzen_und_verlaengern.php). Dort kann man z.B. auch direkt die nötigen Anträge (natürlich speziell für die IHK Oldenburg) herunterladen.

Habt ihr eure Ausbildung verkürzt? Wenn ja, wie lange hat sie gedauert? Seid ihr rückblickend zufrieden mit der Entscheidung? Oder habt ihr noch vor, eure Ausbildungszeit zu verkürzen?

Einführung in Twitter Bootstrap

Veröffentlicht am 23.10.2015

Wer ab und an mal eine Website gestaltet, hat vielleicht nicht immer Zeit und Lust, sich stundenlang mit der optimalen Kombination von HTML und CSS auseinanderzusetzen, die dann auch noch in allen Browsern und auf allen Geräten vernünftig aussieht.

Seit einiger Zeit hat sich Twitters Framework Bootstrap quasi zum Standard unter den Frontend-Frameworks entwickelt: Bootstrap · The world’s most popular mobile-first and responsive front-end framework. (Link: http://getbootstrap.com/). Ich erkenne allerdings häufig auf den ersten Blick, wenn eine Seite mit Bootstrap erstellt wurde, da gewisse Inhaltselemente sich nun einmal wiederholen.

Wer etwas mehr Individualität haben möchte, dem sei der StyleBootstrap.info: Twitter Bootstrap theme generator (Link: http://stylebootstrap.info/) empfohlen. Mit ihm kann man das allseits bekannte Aussehen des Frameworks zumindest an die eigenen Vorlieben anpassen.

Ich selbst habe schon ein paar Websites mit Bootstrap erstellt und bin absolut zufrieden damit. Es ist einfach zu bedienen, man kann (in der neusten Version) auch semantisches Markup verwenden und es sieht einfach auf allen Plattformen vernünftig aus. Das spart letztlich eine Menge Zeit, die ich für die eigentlichen Inhalte aufwenden kann, anstatt mit dem Browser zu kämpfen.

Wie für so ziemlich alle Web-Technologien hat Pluralsight auch für Bootstrap den passenden Kurs, den ich auch selbst absolviert habe und weiterempfehlen kann.

Wer heutzutage ernsthaft eine Website bauen will, kommt nicht am Responsive Webdesign vorbei, um alle Plattformen vom Desktop bis zum Handy optimal zu bedienen. Das lässt sich allerdings auch wunderbar mit Bootstrap kombinieren. Eine sehr gute allgemeine Einführung ins Thema gibt es – wo auch sonst – wieder bei Pluralsight. Auch diesen Kurs habe ich selbst absolviert und empfehle ihn gerne weiter.

Entwickelt ihr selbst auch Frontends? Oder seid ihr eher im Backend unterwegs? Wenn ihr Websites baut, welche Frameworks setzt ihr ein? Habt ihr schon Erfahrungen mit Bootstrap gemacht?

Warum ich Markdown liebe

Veröffentlicht am 16.10.2015

Ich produziere laufend irgendwelche Texte. Seien es Blogposts, Shownotes für den Anwendungsentwickler-Podcast (Link: http://anwendungsentwicklerpodcast.de/), Stefan Mackes Wiki (Link: http://wiki.macke.it) oder sonstige Artikel (wie z.B. diesen hier: Integrationsspektrum: Smells like Java – Softwareentwicklung mit Natural (Link: http://www.sigs-datacom.de/fachzeitschriften/javaspektrum/archiv/artikelansicht.html?tx_mwjournals_pi1%5Bpointer%5D=0&tx_mwjournals_pi1%5Bmode%5D=1&tx_mwjournals_pi1%5BshowUid%5D=7900)). Lange Zeit habe ich überlegt, wie ich meine verschiedenen Texte auf Basis einer gemeinsamen und einfachen Syntax schreiben kann.

Seit einigen Monaten verwende ich nun markdown.de | Markdown Syntax-Dokumentation (Link: http://markdown.de/) für alle meine Texte. Und ich bin begeistert. Es gibt ein WordPress-Plugin (WordPress › WP-Markdown « WordPress Plugins (Link: https://wordpress.org/plugins/wp-markdown/)), ein Plugin für DokuWiki (plugin:markdowku [DokuWiki] (Link: https://www.dokuwiki.org/plugin:markdowku)) und einen netten WYSIWYG-Editor für Windows (MarkdownPad – The Markdown Editor for Windows (Link: http://markdownpad.com/)).

Man kann Markdown in alle möglichen anderen Formate konvertieren, z.B. in HTML und LaTeX (und was braucht man mehr? 😉 ). Und auch bekannte Softwareentwickler wie Miguel de Icaza setzen Markdown ein: Markdown Style Guide – Miguel de Icaza (Link: http://tirania.org/blog/archive/2014/Sep-30.html). Selbstverständlich sind die reinen Textdateien perfekt geeignet, um sie mit Git zu versionieren. Kein Wunder, dass GitHub für alle Readmes Markdown verwendet.

Die Syntax ist sehr einfach zu lernen. Und wer will, kann sich gleich den passenden Kurs bei Pluralsight anschauen:

Wie dokumentiert ihr eure Arbeit oder schreibt Artikel? Habt ihr schon einmal mit Markdown gearbeitet? Was haltet ihr davon?

Ein sinnvoller Git-Workflow

Veröffentlicht am 09.10.2015

Wir sind aktuell dabei, unseren eigenen Entwicklungsprozess auf Basis von Git neu zu gestalten und die Entwickler optimal bei der täglichen Arbeit zu unterstützen. Insbesondere die Frage nach dem Deployment von Änderungen auf die unterschiedlichen Stages (Entwicklung, Qualitätssicherung, Produktion) ist dabei ein wichtiger Punkt.

Einen spannenden Ansatz verfolgt der „Git Flow“-Prozess, wie er von Vincent Driessen beschrieben wurde: A successful Git branching model » nvie.com (Link: http://nvie.com/posts/a-successful-git-branching-model/) (siehe auch dieses gute git-flow cheatsheet (Link: http://danielkummer.github.io/git-flow-cheatsheet/) und Git Workflows and Tutorials | Atlassian Git Tutorial (Link: https://de.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow)). Auf Basis von Feature-Branches werden die Änderungen nach und nach in die nächste Stage gemergt.

Allerdings deckt der Prozess nicht all unsere Anforderungen ab. Insbesondere ist für uns wichtig, Features selektiv auf die nächste Stage zu bringen und dabei evtl. schon gemergte Features wieder zu entfernen, weil sie z.B. Probleme bereiten. Daher haben wir uns an diesem Modell orientiert, dass es auch erlaubt, Features wieder zu entfernen und Branches komplett neu aufzubauen: A pragmatic guide to the Branch Per Feature git branching strategy | Acquia (Link: https://dev.acquia.com/blog/pragmatic-guide-branch-feature-git-branching-strategy) (basierend auf Branch-per-Feature – Adam Dymitruk (Link: http://dymitruk.com/blog/2012/02/05/branch-per-feature/)).

Wenn das Ganze fertig ist, werde ich noch einmal etwas dazu schreiben. Bis dahin: Welchen Workflow setzt ihr ein? Verwendet ihr Git oder ein anderes Versionsverwaltungssystem?

Kommentare

  • Von Robin Schneider (Link: https://github.com/ypid) am 29.10.2015
    Hallo Stefan, ich habe mir „Git Flow“ mal angeschaut für ein privates Projekt (Link: https://github.com/ypid/opening_hours.js) allerdings dann wieder verworfen. Für meinen Anwendungsfall ist es übertrieben. Mir reicht es, wenn ich „Featrue Branches“ für jede neue Funktion aufmache und den Rest (mit ausreichend Unit-Tests natürlich 🙂 ) direkt auf master commite. Für eine Firma oder größere Organisation muss man sich zu solche Fragen natürlich mehr Gedanken machen. Beispielsweise die Entwickler des Linux Kernel haben ähnliche Anforderungen und auch Lösungen für diese Probleme gefunden. Greg Kroah-Hartman benutzt (Link: https://usesthis.com/interviews/greg.kh/) hierzu quilt (Link: https://savannah.nongnu.org/projects/quilt) zusammen mit git. Ich habe, wie gesagt, keinen Anwendungsfall aktuell dafür aber vielleicht ist es ja etwas für dich/deinen Anwendungsfall. Zu deiner Frage zum verwendeten VCS. Heutzutage ausschließlich git. Hin und wieder hat man noch mit SVN, Mercurial oder Bazaar zu tun allerdings kann man diese meines Wissens alle lokal mit git verwalten oder Upstream zur Migration (Link: https://github.com/netblue30/firejail/issues/10) bewegen (Link: http://doublecmd.sourceforge.net/forum/viewtopic.php?t=1742&p=14512#p14512) 🙂

  • Von Stefan Macke am 29.10.2015
    Hallo Robin,

    ich stimme dir zu, dass Git Flow für „kleine“ Projekte überdimensioniert ist. In unserem Fall suchen wir nach dem optimalen Prozess für eine zentrale Anwendung, die mit 20 Entwicklern gleichzeitig weiterentwickelt wird. Dafür scheint Git Flow eine gute Basis zu sein.

    Danke für die interessanten Links!

    Viele Grüße! Stefan

Wie man dank Softwarefehlern schnell viel Geld verliert

Veröffentlicht am 02.10.2015

In letzter Zeit häufen sich die Berichte von Entwicklern, die horrende Rechnungen von Cloud-Anbietern – wie z.B. Amazon EC2 oder Microsoft Azure – erhalten, weil Hacker auf ihre Kosten virtuelle Maschinen gestartet haben (um z.B. nach Bitcoins zu suchen). Ein Beitrag bei humankode führt das Ganze auf einen Bug in Visual Studio zurück: How a bug in Visual Studio 2015 exposed my source code on GitHub and cost me $6,500 in a few hours (Link: https://www.humankode.com/security/how-a-bug-in-visual-studio-2015-exposed-my-source-code-on-github-and-cost-me-6500-in-a-few-hours). In diesem Fall konnte der Entwickler wohl nichts dafür. Allerdings hätte ich bei so sensiblen Daten wie Schlüsseln für Clouds vielleicht etwas genauer hingeschaut.

Anscheinend reicht ein einziger falscher Commit und die Daten werden von Crawlern automatisiert verwendet, um Unfug damit zu treiben. Jeff Reifman zeigt in diesem Artikel, was er tut, um seine Schlüssel gar nicht erst ins Repo einzustellen: Protecting Your Keys From GitHub – Tuts+ Code Tutorial (Link: http://code.tutsplus.com/tutorials/protecting-your-keys-from-github–cms-23002).

Softwarefehler müssen nicht immer gleich Geld kosten. Aber ob der Verlust der eigenen Daten besser ist, weiß ich auch nicht. Laut diesem Artikel führte ein Bug in Steam zu genau diesem Resultat: Moved ~/.local/share/steam. Ran steam. It deleted everything on system owned by user. · Issue #3671 · ValveSoftware/steam-for-linux (Link: https://github.com/ValveSoftware/steam-for-linux/issues/3671)

Was habt ihr schon für üble Softwarefehler gesehen? Oder habt ihr gar selbst welche produziert?

Kommentare

  • Von Anna (Link: http://rechnungsverwalter.de) am 19.10.2015
    Das waren dann aber böse und kostspielige Fehler, wenn andere den Traffig verbrauchen können. Selbst kenn ich jetzt keine größeren Softwarefehler. Zum Glück!

Brennst du fürs Programmieren?

Veröffentlicht am 25.09.2015

Viele Softwareentwickler sehen das Programmieren nur als Job und nicht als ihre Leidenschaft. Antonin Januska hat zu diesem Thema einen interessanten Artikel geschrieben: I’m a developer, but it’s not my passion (Link: http://antjanus.com/blog/thoughts-and-opinions/im-a-developer-but-its-not-my-passion/).

Ich würde von mir selbst sagen, dass ich für das Programmieren brenne und es nicht nur als Job sehe. Das muss ich auch, da ich es sonst wahrscheinlich kaum meinen Auszubildenden und Studierenden vermitteln könnte.

Und ich glaube auch nicht, dass ich freiwillig Anwendungsentwickler-Podcast (Link: http://anwendungsentwicklerpodcast.de/) aufnehmen würde, um angehenden Anwendungsentwicklern zu helfen, wenn mir das Programmieren nicht so viel Spaß machen würde.

Ich zitiere daher immer gern Augustinus Aurelius:

In dir muss brennen, was du in anderen entzünden willst.

Brennst du auch fürs Programmieren? Ist Programmieren deine Leidenschaft? Oder siehst du es nur als Mittel zum Zweck?

Kommentare

  • Von Max Falk am 26.09.2015
    Hallo Stefan, zu dem Thema gab es kürzlich auch einen interessanten Querschnitt auf Quora: https://www.quora.com/Do-most-programmers-really-enjoy-programming Im Konzernumfeld kommt es mir so vor, als würden die wenigsten Entwickler für ihre Profession brennen. Mit Linux, vim oder regular expressions kann kaum einer etwas anfangen. Oft haben sie sich auf eine Sprache/Umgebung festgelegt und machen in ihrer Freizeit nichts mit Software. Finde ich sehr schade und es fällt mir schwer, dabei wertungsfrei zu bleiben, weil die Werkzeuge und das Potential oft nicht ausgenutzt werden. Andererseits kann man grade bei „9 to 5“-Entwicklern oft erstaunlich viel über Produktivität lernen. Was man in seiner Freizeit macht, ist ja jedem selbst überlassen. Der kulturelle Hype für Softwareentwicklung ist im deutschen Raum wohl einfach noch nicht so weit wie in den USA. Dafür gibt es in unserem Umfeld viele selbstständige Softwareentwickler, die davon leben, sich konstant weiterzubilden und privat auch mal Projekte bauen, oft mit dem Ziel diese zu verkaufen. Das hält fit und die brennen dann tatsächlich oft für die Programmierung! VG, Max

  • Von Stefan Macke am 27.09.2015
    Hallo Max,

    vielen Dank für den Link. Den kannte ich noch nicht.

    Ich kann deinen Eindruck bestätigen: Viele Entwickler, die ich kenne, sehen Programmieren nur als ihren Job. Was ja auch völlig ok ist.

    Für alle anderen gibt es ja genug Möglichkeiten, sich auszutauschen. Dafür habe ich z.B. den Softwareentwickler-Stammtisch (Link: http://softwareentwicklerstammtisch.de/) ins Leben gerufen. Da ist die Teilnahme freiwillig und es kommen daher nur Entwickler, die richtig Bock aufs Entwickeln haben 🙂

    Viele Grüße! Stefan

Tipps für mehr Bewegung am Arbeitsplatz

Veröffentlicht am 18.09.2015

Ich stelle schon seit geraumer Zeit Themen für eine Anwendungsentwickler-Podcast (Link: http://anwendungsentwicklerpodcast.de/)-Episode zur ergonomischen Arbeitsplatzgestaltung zusammen und letzte Woche bin ich über diese tolle Liste bei Ergotopia gestolpert, die ich unbedingt weiterempfehlen möchte: 18 geniale Tipps für mehr Bewegung am Arbeitsplatz (Link: http://www.ergotopia.de/blog/mehr-bewegung-am-arbeitsplatz).

Seit ich die Gründer von Ergotopia in einem Podcast (siehe Arbeiten ergonomisch – Interview mit den Jungs von Ergotopia (Link: http://www.markuscerenak.com/eml-079-nterview-ergotopia.html)) gehört habe, verfolge ich ihren Blog. Ich habe schon einige tolle Tipps für mehr Bewegung am Arbeitsplatz von ihnen bekommen.

Gerade wir als Anwendungsentwickler, die wirklich viel Zeit am PC verbringen (und auch meistens lange Zeit am Stück), sollten auf eine ergonomische Gestaltung unseres Arbeitsplatzes achten.

Wie hältst du es mit der Gesundheit am Arbeitsplatz? Machst du regelmäßig Pausen? Wendest du vielleicht sogar die Staffan Noteberg – Pomodoro Technique Illustrated (Affiliate)* an? Hast du noch mehr Tipps für mehr Bewegung bei der Arbeit? Dann immer her damit! Man kann gar nicht genug zur gesunden Gestaltung seines Arbeitsplatzes wissen.

Meine Top 5 Eclipse-Plugins

Veröffentlicht am 11.09.2015

Angeregt durch die Liste der Top 10 der populärsten Eclipse-Plug-ins (Link: https://jaxenter.de/top-10-der-populaersten-eclipse-plug-ins-22795) kommt hier meine Liste der (für mich) wichtigsten Eclipse-Plugins:

  1. Vrapper — Vim-like editing in Eclipse (Link: http://vrapper.sourceforge.net/home/)
    Jede IDE sollte sich steuern lassen wie welcome home : vim online (Link: http://www.vim.org/)! 😀
  2. MouseFeed | Eclipse Plugins, Bundles and Products – Eclipse Marketplace (Link: https://marketplace.eclipse.org/content/mousefeed)
    Ich hasse die Maus! Dieses Plugin zeigt zu jedem Mausklick den möglichen Tastatur-Shortcut und ermöglicht sogar das Sperren der Maus.
  3. MoreUnit (Link: http://moreunit.sourceforge.net/)
    Mit einem Tastendruck zwischen Test und Implementierung hin- und herspringen!
  4. Infinitest (Link: http://infinitest.github.io/)
    Tests automatisch bei Änderungen an betroffenen Klassen ausführen.
  5. TeXlipse homepage – LaTeX for Eclipse (Link: http://texlipse.sourceforge.net/)
    Die einzige vernünftige Entwicklungsumgebung für LaTeX 😉

Welche Plugins verwendet ihr? Wie und warum helfen sie euch bei der Arbeit? Oder nutzt ihr eure IDE vielleicht ganz ohne Plugins?

Kommentare

  • Von Robin Schneider (Link: https://github.com/ypid) am 11.09.2015
    Hallo Stefan, ich bin ja FiSi und bin in vielen Programmiersprachen und auf Linux unterwegs. Für mich kommt nur Vim (Link: https://de.wikipedia.org/wiki/Vim) mit einer langen Liste an Plugins und Konfigurationen (Link: https://github.com/ypid/dotfiles/blob/master/.vimrc) infrage. Wenn man sich auf ein paar Sprachen konzentrieren kann, ist eine IDE vermutlich eine gute Sache, da diese mehr Unterstützung bieten kann als ein generischer Editor (ohne viel Konfiguration). Zweiter Punkt für Vim ist, dass man damit auch problemlos auf Servern übers Netzwerk entwickeln kann, wenn man beispielsweise gegen eine API eines Gerätes schreibt, die beim Kunden steht. Was mir in dem Kontext noch einfällt, sind andere Tastatur Layouts als QWERTZ (Link: https://de.wikipedia.org/wiki/QWERTZ-Tastaturbelegung) (das meiner Ansicht nach zum Programmieren ungeeignet ist.). Ich benutzte deshalb Neo2 (Link: http://www.neo-layout.org/) kombiniert mit QWERTZ für Buchstaben (Link: https://github.com/ypid/dotfiles/tree/master/xkb).

  • Von Stefan Macke am 11.09.2015
    Deinen Editor-Geschmack kann ich natürlich nachvollziehen 🙂 Der Vim ist ungeschlagen!

    Für die Java-Entwicklung würde ich allerdings wirklich lieber auf eine IDE setzen. Bei Ruby u.a. sieht das schon wieder anders aus, da die IDE aufgrund der dynamischen Typisierung eh nicht allzu viel helfen kann.

    Beim Tastaturlayout würde ich mich aber sehr schwer tun mit einem anderen Layout. Wenn ich dann den Rechner wechsle, müsste ich mich ja jedes Mal umstellen.

  • Von Robin Schneider (Link: https://github.com/ypid) am 11.09.2015
    Zum Tastaturlayout: Wenn man an anderen Rechnern ist, muss man es natürlich wieder einstellen. Mit meiner Kombination aus QWERTZ und Neo2 könnte ich beispielsweise nicht auf Windows arbeiten, da meine Config da nicht läuft (Link: https://github.com/ypid/dotfiles/tree/master/autohotkey). Allerdings finde ich, gerade für Entwickler, die Frage nach dem Tastaturlayout interessant. Auch hat man als Entwickler meist einen Computer. Da hat man es als FiSi teils schwerer in Kundenumgebungen oder Ähnlichem. Die Umstellung, wenn man das eigene Layout nicht benutzen kann, ist nicht so schwierig. Viele die Neo2 benutzen können auch mit QWERTZ noch schnell tippen, wenn nötig. Mir geht es auch so, auch wenn ich ja nur die Sonder- und Funktionstasten wieder „ummappen“ muss 🙂 Das Killer-Feature von Neo2 ist immer noch, das ich um Enter oder Löschen zu drücken, die „home row“ verlassen muss. Und natürlich die Klammern.

  • Von Stefan Macke am 12.09.2015
    Ich habe schon viel von anderen Tastaturlayouts gehört (insb. Dvorak-Tastaturbelegung – Wikipedia (Link: https://de.wikipedia.org/wiki/Dvorak-Tastaturbelegung) kommt immer mal wieder hoch), aber kann mir nicht vorstellen, dass ich damit tatsächlich schneller oder besser tippen kann. Ich vermute (ohne es ausprobiert zu haben), dass die Einarbeitungs- und Umgewöhnungszeit sehr hoch ist und die praktischen Nachteile (z.B. erneute Umgewöhnung beim Pair Programming oder auf fremden Rechnern) überwiegen. Das „normale“ 10-Finger-System sollte man als ITler natürlich beherrschen.

  • Von Robin Schneider (Link: https://github.com/ypid) am 13.09.2015
    Die Umgewöhnung ist nicht ganz ohne, das ist klar. Wenn man aber bedenkt, wie viel man in unserem Beruf an der Tastatur hängt (und noch wird), finde ich auch eine sehr hohe Umgewöhnung gerechtfertigt. Aber das ist vermutlich nicht jedermanns Sache. Ich finde es cool 😉

  • Von Robin Schneider (Link: https://github.com/ypid) am 19.11.2015
    Noch ein kleiner Nachtrag. qNeo2 (Link: https://github.com/ypid/dotfiles/tree/master/qNeo2#autohotkey-on-m-windows) läuft doch auf Windows und lässt sich auch sehr einfach einrichten. Dein Argument zum fremden Rechner kann ich somit entkräften. Auch der Punkt wegen umschalten bei Pair Programming ist mit einem Tastendruck getan (CapsLook/Mod3 + Pause). Die Umgewöhnung bei qNeo2 sollte ebenfalls noch im Rahmen sein, da es ja nur um die Sondertasten geht. Falls im Winter mal Langeweile aufkommt 🙂

  • Von Stefan Macke am 20.11.2015
    Hehe 🙂 Ich sehe schon, du bist missionarisch unterwegs 😉

  • Von Markus Amshove (Link: https://amshove.org) am 21.11.2015
    Hallo Stefan, bei mir gehört mittlerweile saneclipse (Link: http://saneclipse.vogella.com/) dazu. Dies fügt bspw. die statischen Importvorschläge für mockito, hamcrest etc. ein. Außerdem gibt es einen Vollbildmodus (blendet einige Elemente aus, aber leider nicht die Taskbar) und man kann mit CTRL + + und CTRL + – die Schriftgröße verändern, gerade die beiden Sachen finde ich sehr wichtig wenn man mal was am Beamer o.ä. zeigen möchte. Um sich alle Features anzuschauen muss man leider in den Sourcecode (Link: https://github.com/vogellacompany/com.vogella.saneclipse/blob/master/com.vogella.saneclipse.preferences/src/com/vogella/saneclipse/preferences/internal/PreferenceInitializerAddon.java). Sieht auch wie eine nette Möglichkeit aus im Unternehmen Codeconventions zu verteilen, da man ein Plugin updaten kann und das manuelle importieren gerne mal vergessen wird 🙂

  • Von Stefan Macke am 21.11.2015
    Cool! Das mit der Schriftgröße ist ja genial! Brauche ich ständig bei Präsentationen 🙂 Danke für den Tipp!

Pflichtlektüre rund um Zeichensätze und Encodings

Veröffentlicht am 04.09.2015

Bei der Einführung in HTML mit meinen Azubis schiebe ich immer gerne einen Exkurs zum Thema Encoding ein, da dies – zusammen mit den verschiedenen möglichen Zeilenumbrüchen – häufig zu Problemen und Fragen bei der praktischen Arbeit mit Textdateien führt. Als Einstiegslektüre empfehle ich dazu die folgenden Artikel von Joel Spolsky und Gatunka:

  • The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) (Link: http://www.joelonsoftware.com/articles/Unicode.html)
  • Character Encodings For Modern Programmers (Link: http://blog.gatunka.com/2014/04/25/character-encodings-for-modern-programmers/)

Ich bin der Meinung, dass jeder Softwareentwickler über die verschiedenen Encodings bescheid wissen sollte. Man darf z.B. „unseren“ Zeichensatz ISO 8859-1 (Link: https://de.wikipedia.org/wiki/ISO_8859-1) auswendig kennen (daher frage ich ihn sogar in meinen Lernzielkontrollen ab; ich meine natürlich nur den Namen und nicht die ganze Code-Tabelle 😛 ) Gerade wenn bei der Arbeit mit Textdateien Probleme mit Umlauten usw. auftreten, tut man gut daran, zu verstehen, warum das der Fall ist und was man dagegen tun kann.

Wie seht ihr das? Habt ihr auch schon einmal Probleme mit Zeichensätzen gehabt? Fragt eure/-er Ausbilder/-in auch die üblichen Encodings ab? 😉

Von guten und schlechten regulären Ausdrücken

Veröffentlicht am 28.08.2015

In diesem (zumindest für mich 😉 ) spannenden Artikel zeigt Liz Bennett die – teils sehr deutlichen – Performance-Unterschiede zwischen guten und schlechten Regulärer Ausdruck – Wikipedia (Link: https://de.wikipedia.org/wiki/Regul%C3%A4rer_Ausdruck): Regexes: the Bad, the Better, and the Best (Link: https://www.loggly.com/blog/regexes-the-bad-better-best/).

Reguläre Ausdrücke sind eines meiner Lieblingswerkzeuge und ich denke, dass alle Informatiker – und gerade die Softwareentwickler – sie beherrschen sollten. Ein Texteditor, der nicht mit regulären Ausdrücken arbeiten kann (z.B. beim Suchen und Ersetzen), ist für mich kein Texteditor. Daher finde ich es spannend zu lesen, welche Performance-Unterschiede es bei den verschiedenen Variationen gibt.

Wie seht ihr das? Arbeitet ihr mit regulären Ausdrücken? Wofür setzt ihr sie ein? Hattet ihr Probleme beim Verständnis oder waren sie einfach zu lernen?

10x-Rockstar-Ninja-Programmierer

Veröffentlicht am 21.08.2015

Seit langem gibt es den Begriff des „10x-Programmierers“, der angeblich 10 mal so produktiv ist wie ein „normaler“ Programmierer. An anderer Stelle liest man auch gerne vom „Rockstar-“ oder „Ninja-Programmierer“.

Vor Kurzem gab es bei JAXenter einen Artikel zu diesem Thema: Kennen Sie die Mythos des Rockstar-Programmierers? – jaxenter.de (Link: https://jaxenter.de/kennen-sie-die-mythos-des-rockstar-programmierers-2302). Selim Baykara fasst darin die Aussagen zweier Blog-Artikel zusammen, die gegensätzlicher Ansicht sind:

  • The 10x developer is NOT a myth (Link: http://www.ybrikman.com/writing/2013/09/29/the-10x-developer-is-not-myth/)
  • The Myth of the Rockstar Programmer – Scott Hanselman (Link: http://www.hanselman.com/blog/TheMythOfTheRockstarProgrammer.aspx)

Ich glaube, dass es – wie in jeder Branche und bei jeder Tätigkeit – Menschen gibt, die etwas besser können als andere. Ob das gleich zehnmal so gut ist, kann ich nicht beurteilen. Dafür kann man sich ja die in den Artikeln verlinkten Studien anschauen.

Ich denke aber, dass man stets versuchen sollte, seine Aufgaben bestmöglich zu erledigen. Und gerade bei der Programmierung erkenne ich schon Unterschiede zwischen interessierten Entwicklern, die sich z.B. selbständig fortbilden, zu Softwareentwickler-Stammtisch (Link: http://softwareentwicklerstammtisch.de) gehen und Lust auf neue Programmiersprachen haben, und den 9-to-5-Programmierern (oder der Dark Matter Developers: The Unseen 99% – Scott Hanselman (Link: http://www.hanselman.com/blog/DarkMatterDevelopersTheUnseen99.aspx), wie Scott Hanselman sie nennt).

Wie seht ihr das? Merkt ihr selbst auch Unterschiede in der Produktivität einzelner Entwickler? Wie schätzt ihr euch selbst ein?

Java Deathmatch

Veröffentlicht am 14.08.2015

Beim Java Deathmatch | Takipi (Link: http://www.javadeathmatch.com/) kann man seine Kenntnisse als Java-Entwickler unter Beweis stellen. Für die Beantwortung der teils sehr schwierigen Aufgaben muss man schon wirklich tief in der Materie stecken.

Von Blog von Markus Amshove (Link: http://amshove.org) habe ich passend dazu einen Link zu einer Analyse der fünf schwierigsten Aufgaben bekommen: 4 out of 5 Java Developers Failed to Solve This Question | Takipi Blog (Link: http://blog.takipi.com/4-out-of-5-java-developers-failed-to-solve-this-question/). Die schwierigste Aufgabe wurde nur von 20% der Kandidaten richtig beantwortet. Das heißt, man hätte besser raten können 😉

Ich finde solche Fragen immer sehr spannend, da sie zeigen, dass man teilweise noch einiges zu lernen hat, auch auf einer Plattform, mit der man vielleicht seit Jahren arbeitet. Wie seht ihr das? Habt ihr vielleicht Beispiele für weitere „Deathmatches“?

Wichtige Datenstrukturen verständlich erklärt

Veröffentlicht am 07.08.2015

Stacks, Queues, Heaps und Hashmaps sind wichtige Datenstrukturen, die jeder Softwareentwickler kennen sollte. Auch wenn sie meist bei der alltäglichen Arbeit wenig Anwendung finden werden.

Auf der Seite Algosaurus | A graphic guide to algorithms. (Link: http://algosaur.us/) gibt es eine witzig geschriebene Einführung in die genannten Datenstrukturen:

“It’s turtles all the way down.” – A guide to the Basics of Data Structures | Algosaurus (Link: http://algosaur.us/data-structures-basics/)

Auch spannende Themen wie “To iterate is human, to recurse, divine.” – A guide to Recursion | Algosaurus (Link: http://algosaur.us/recursion/) oder Such complex, very wow – A guide to Algorithmic Complexity | Algosaurus (Link: http://algosaur.us/algorithmic-complexity/) werden anschaulich erklärt. Eine tolle Seite gerade für Programmiereinsteiger, die die abstrakten Datenstrukturen gerade erst kennenlernen.

Wie sieht es bei euch aus? Habt ihr schon einmal einige der Datenstrukturen in euren Programmen verwendet? Eine Hashmap bestimmt, aber ein Heap ist bestimmt deutlich seltener anzutreffen, oder?

Bildquellen für die Projektpräsentation

Veröffentlicht am 31.07.2015

Passend zur Veröffentlichung von Projektpräsentation von Markus Amshove (mit 100% bewertet) habe ich diese Woche ein paar Links zu Websites mit kostenlosen Bildern für euch:

  • Pixabay (Link: https://pixabay.com/)
  • Free Images (Link: http://www.freeimages.com/)
  • Public Domain Pictures (Link: http://publicdomainpictures.net/)
  • Flickr (Link: https://www.flickr.com/)

Achtet bitte auf die jeweils verwendete Lizenz. Mit Creative Commons (Link: http://creativecommons.org/) könnt ihr meistens nicht verkehrt machen, solange ihr euch an die Best practices for attribution – Creative Commons (Link: https://wiki.creativecommons.org/wiki/Best_practices_for_attribution) haltet und z.B. den Autor des Bildes nennt.

Kommentare

  • Von Manuel (Link: http://nordkrater.de) am 22.01.2016
    Wer nicht alle Seiten einzeln durchforsten möchte, kann sich das hier auch mal ansehen: http://finda.photo/ Hier sind die Fotos alle „CC0“, also gemeinfrei, wodurch auch eine Nennung des Autors bzw. der Quelle wegfällt.

  • Von Stefan Macke am 22.01.2016
    Hallo Manuel,

    die Seite kannte ich noch nicht. Danke für den Tipp! Sieht auf den ersten Blick echt gut aus.

    Viele Grüße! Stefan

Einführung in Reactive Programming

Veröffentlicht am 24.07.2015

Blog von Venkat Subramaniam (Link: http://blog.agiledeveloper.com/) zeigt in diesem Video in seinem ganz persönlichen (aber wie ich finde erfrischenden) Präsentationsstil, was Reactive Programming ist: Parleys.com – Reactive Programming for Java Programmers by Venkat Subramaniam (Link: https://old.parleys.com/share_channel.html#play/543f98cae4b06e1184ae418f).

Das Thema geistert ja nun schon länger durch die verschiedensten Entwicklerkonferenzen. Wie seht ihr das? Habt ihr schonmal „reactive“ programmiert? Wenn ja, mit welcher Programmiersprache? Und habt ihr tatsächlich Vorteile durch diese Programmierung gehabt?

Wie man in Java 8 über Collections iteriert

Veröffentlicht am 17.07.2015

…zeigt John I. Moore in dieser guten Einführung ins Thema: Iterating over collections in Java 8 (Link: http://www.javaworld.com/article/2461744/java-language/java-language-iterating-over-collections-in-java-8.html).

Angefangen mit Enumerations, über das Iterator-Pattern und die foreach-Schleife, bis hin zur modernen funktionalen Iteration mit Streams wird die komplette Entwicklung von Java im Bereich der Iteration über Collections vorgestellt. Eine sehr schöne Einführung wie ich finde!

Wie ist das bei euch? Setzt ihr schon fleißig die neuen funktionalen Features ein? In vielen Abschlussprojekten sehe ich die Ansätze schon. Wobei allerdings die wenigsten Prüflinge tatsächlich erklären können, was da vor sich geht (siehe Rückblick auf die Sommerprüfung 2015 – Anwendungsentwickler-Podcast #20 (Link: http://anwendungsentwicklerpodcast.de/20)).

Vererbung mit JavaScript

Veröffentlicht am 10.07.2015

Nur nochmal zur Erinnerung: JavaScript ist keine objektorientierte Programmiersprache im klassischen Sinn wie z.B. Java oder C#. JavaScript ist eine Prototypenbasierte Programmierung – Wikipedia (Link: https://de.wikipedia.org/wiki/Prototypenbasierte_Programmierung). Sie kennt insb. nicht das Konzept einer Klasse. Auch wenn viele Prüflinge da anderer Meinung sind. Und wenn man dann fragt, wie sie denn ihre Klassen programiert haben, führt das meist zu spannenden Diskussionen 😉

In diesem Blog-Beitrag bei Dr. Web wird gezeigt, wie man trotzdem ein Konzept ähnlich der Vererbung in JavaScript umsetzen kann: Nicht OOP, aber nah dran: Einfache Vererbung mit JavaScript | DR. WEB (Link: http://www.drweb.de/magazin/nicht-oop-aber-nah-dran-einfache-vererbung-mit-javascript-59542/).

Kommentare

  • Von Dominik Pesch (Link: http://www.11com7.de) am 25.08.2015
    Nur eine Ergänzung: Mit ECMAScript 6 (der eigentliche Standard hinter den »JavaScript«-Dialekten) wird aktuelle wieder ganz eifrig »gestritten« (u. a. http://www.quora.com/Is-ECMAScript-6-a-kind-of-object-oriented-programming-language (Link: http://www.quora.com/Is-ECMAScript-6-a-kind-of-object-oriented-programming-language)), ob es eine OOP-Sprache ist/sein kann. Denn es sind jetzt auch neben Klassen-Definitionen (vgl. Class Definitions, ECMAScript® 2015 Language Specification (Link: http://www.ecma-international.org/ecma-262/6.0/#sec-class-definitions)) noch weitere OOP-Funktionalitäten in die Sprache aufgenommen worden: Konstruktoren Methoden-Definitionen (vereinfachte/ähnliche Schreibweise) Getter/Setter (von ECMA5) (siehe u. a. http://www.2ality.com/2014/12/es6-oop.html) PS: sorry für die vielen Links. JS/ECMAScript 6 »kennt« dann das Konzept der Klasse, auch wenn es – zumindest aus den Augen von Kritikern – nur der berühmte »syntaktische Zucker« (»syntactic sugar«) ist.
  • Von Stefan Macke am 25.08.2015
    Hallo Dominik, vielen Dank für die Links! Gut zu wissen, das sich im Bereich ECMAScript einiges tut. Die Artikel landen direkt auf der ToRead-Liste 😉 Viele Grüße! Stefan

Was sind eigentlich Microservices?

Veröffentlicht am 03.07.2015

Aktuell scheinen Microservices der neue Hype in der Softwarearchitektur zu sein. Meine Links der Woche sind zwei Artikel zu diesem Thema:

  • Microservices – häufig gestellte Fragen – jaxenter.de (Link: https://jaxenter.de/microservices-haeufig-gestellte-fragen-21282) (von Coman Hamilton und Mark Little)
  • Microservices (Link: http://martinfowler.com/articles/microservices.html) (von James Lewis und Martin Fowler)

Ich bezweifle, dass man als Prüfling aktuell schon etwas zu Microservices sagen können muss, aber es ist sicherlich nicht schlecht, davon gehört zu haben. Wir müssen als Softwareentwickler am Puls der Zeit bleiben und gerade Architekturmuster sind wichtig für Entwickler, die mehr wollen, als nur Code zu schreiben.

Wie sieht es bei euch mit Microservices aus? Setzt schon jemand auf dieses Konzept? Wenn ja, welche Erfahrungen habt ihr damit gemacht?

Test Driven Development mit C# und Java

Veröffentlicht am 26.06.2015

Paul Mooney hat vor einiger Zeit eine gute Einführung in das Thema Test Driven Development mit C# und Java geschrieben: Object Oriented, Test Driven Design in C# and Java (Link: http://insidethecpu.com/2015/01/23/object-oriented-test-driven-design-in-c-and-java/).

Da dürfte für jeden etwas dabei sein. Mit Java und C# hat er ja zwei sehr prominente Sprachen im Enterprise-Umfeld berücksichtigt. Und allein die Domäne – eine Roboterfabrik – ist das Lesen wert 😉

Wie sieht das bei euch aus, testet ihr eure Software mit Unit-Tests? Oder setzt ihr sogar TDD zur Entwicklung ein?

Kommentare

  • Von chena am 01.07.2015
    Hallo, bei uns wird definitiv alles mit automatisierten Tests überprüft. Das reicht von komplexen GUI-Tests bis hin zu winzig kleinen Unittests (beispielsweise, ob in Java compareTo oder equals/hashcode korrekt überschrieben wurden). Manche „Tests“ existieren auch nur, um zu überprüfen, ob eine von mir geworfene Exception „gut“ aussieht. Oder wenn sich mir fremder Code nicht erschließen will, schaue ich mir die Tests an und schreibe notfalls 1-2 eigene, um zu überprüfen, ob ich die Funktionsweise richtig verstanden habe. („Learning Tests“) Und zumindest die Azubis/Werkstudenten werden ebenso definitiv dazu angehalten, testgetrieben zu arbeiten und keine grundlosen Änderungen am Code vorzunehmen. Grundlos heißt in dem Fall: Kein roter Test. Dahinter steckt die Idee, dass bei 100% grünen Tests die Software fehlerfrei funktioniert und niemand an einer fehlerfreien Software rumzudoktorn hat. Am Anfang fand ich es ziemlich schwierig und anstrengend „rückwärts“ zu arbeiten, inzwischen empfinde ich es mehr als Sicherungsnetz und möchte nicht mehr drauf verzichten. Wenn irgendwas kaputt geht, lässt sich durch eine vernünftige Testabdeckung viel leichter eingrenzen, wo das Problem ist, als wenn ich einfach so ins Blaue rate. Erst recht, wenn es nicht mein Code ist oder ich schon ne Weile nicht mehr dran gearbeitet habe. P.S.: Auf diesem Weg ein großes Dankeschön für Blog und Podcast. Einige von den Themen (wie z.B. Normalisierung, gestern erst auf Arbeit gehabt), auch wenn ich noch nicht mal die Zwischenprüfung hatte.

  • Von Stefan Macke am 02.07.2015
    Hallo chena,

    danke für dein Feedback und schön, dass dir die Seite gefällt.

    Ich finde es super, dass bei euch schon von Beginn der Ausbildung an Tests geschrieben werden. Und da du die Zwischenprüfung noch vor dir hast, tippe ich auf 1. Lehrjahr. Dafür machst du einen sehr informierten Eindruck was die Tests angeht. Wenn du das Thema weiter verfolgst, kommt bestimmt ein sehr gut abgesichertes Abschlussprojekt dabei raus 🙂

    Meine Azubis und Studenten werden auch zum Testen angehalten (um nicht zu sagen gezwungen ;-)) und ich finde, das gehört heutzutage zur Ausbildung eines Entwicklers einfach dazu. Schön, dass andere Unternehmen das auch so sehen. Dennoch verwendet aktuell meiner Erfahrung nach noch der Großteil der Prüflinge keine automatischen Tests. Ich bin gespannt, ob und wie sich das in den nächsten Jahren verändert.

    Viele Grüße! Stefan

Veröffentlicht am 19.06.2015

Auf Quora gab es vor einiger Zeit eine sehr interessante Umfrage: What is the hardest thing you do as a software engineer? – Quora (Link: https://www.quora.com/What-is-the-hardest-thing-you-do-as-a-software-engineer) Die erstaunliche (oder eigentlich offensichtliche 😉 ) Antwort der meisten Entwickler ist: Dinge benennen.

Sogar noch vor Antworten wie „Aufwand schätzen“ und „mit dem Code anderer Entwickler arbeiten“!

Phil Johnson hat die Ergebnisse der Umfrage in einem schönen Diagramm dargestellt: Don’t go into programming if you don’t have a good thesaurus | ITworld (Link: http://www.itworld.com/article/2833265/cloud-computing/don-t-go-into-programming-if-you-don-t-have-a-good-thesaurus.html). Und Hartmut Schlosser hat die Ergebnisse noch einmal auf deutsch zusammengefasst: Was ist das größte Problem für Programmierer? Gib mir einen Namen! – jaxenter.de (Link: https://jaxenter.de/was-ist-das-groste-problem-fur-programmierer-gib-mir-einen-namen-2211)

Bei uns ist die häufigste Diskussion im Pair Programming tatsächlich auch die Benennung von Dingen! Wie seht ihr das? Habt ihr auch Probleme mit der Benennung eurer Variablen, Methoden und Klassen?

Kommentare

  • Von Sebastian H am 22.06.2015
    Ganz klar: jein! 😉 Manchmal ist es einfach schwierig den passenden, sprechenden Bezeichner „zu finden“ der nicht alleine die komplette Zeilenlänge ausfüllt. Meistens, so konnte ich das zumindest bei mir beobachten, deuten imho Schwierigkeiten bei der Bennenung von Dingen darauf hin, dass irgendwelche Designfehler vorliegen. Das dann gerne in 2 Ausprägungen: Die Klasse/Methode/etc. macht „zuviel“ (Was auf Verletzung der SoC oder des SRP hindeutet) Die Komponente macht „irgendwie nichts richtig“, was zeigt das man sie in dieser Form auch weglassen ann. Eigentlich sollte es gar nicht so schwer sein einen treffenden Bezeichner zu finden. Man hat sich ja schließlich vorher auch Gedanken gemacht, was beispielsweise die Methode X eigentlich machen soll und gießt das dann in natürliche Sprache. Wenn man sich dann auf das wesentliche beschränkt (calculateValue() statt addXMultiplyYdoStuff()) bleibt der Code auch lesbar … hoffe ich 😀
  • Von Stefan Macke am 22.06.2015
    Hallo Sebastian. Das sehe ich ähnlich. Eigentlich sollte das alles kein Problem sein 😉 Aber spätestens bei der Diskussion mit anderen Entwicklern stelle ich dann häufig fest, dass die eigene Benennung doch nicht so selbsterklärend war. Ein weiterer Grund für Pair Programming 🙂

Veröffentlicht am 12.06.2015

In einem kürzlich veröffentlichten Blog-Artikel beschreibt Santiago L. Valdarrama 5 Probleme, die sich gut für Einstellungstests im Bereich Softwareentwicklung eignen: Five programming problems every Software Engineer should be able to solve in less than 1 hour (Link: https://blog.svpino.com/2015/05/07/five-programming-problems-every-software-engineer-should-be-able-to-solve-in-less-than-1-hour).

Ich selbst nutze immer Fizz Buzz Test (Link: http://c2.com/cgi/wiki?FizzBuzzTest) dafür, aber Santiagos Beispiele sind auch sehr interessant. Sie lassen sich in relativ kurzer Zeit lösen, aber erfordern zumindest ein grundlegendes Verständnis der Programmierung.

Wenn ihr Spaß am Lösen mathematischer Probleme habt, empfehle ich auch noch Project Euler (Link: https://projecteuler.net/). Dort findet ihr über 500 Probleme, die sich mehr oder weniger einfach mit der Programmiersprache eurer Wahl lösen lassen.

Kommentare

  • Von Joe (Link: https://trainyourprogrammer.de) am 11.03.2017
    Hallo, auch unter https://trainyourprogrammer.de gibt es viele Programmieraufgaben.

Veröffentlicht am 05.06.2015

Es gibt einige Dinge, die man tun kann, um in der Entwickler-Community aktiv zu werden. Dazu gehören Bloggen, die Mitarbeit an Open Source-Projekten oder die Teilnahme an Konferenzen (z.B. dem Java Forum Nord (Link: http://javaforumnord.de/)). Bereits als Auszubildende könnt ihr euch auf vielfältige Weise einbringen.

Scott Hanselman und Rob Conery zeigen in ihrem kostenlosen Pluralsight-Kurs einige Beispiele, warum es sinnvoll und letztlich auch sehr nützlich sein kann, mit anderen Entwicklern zu interagieren:

Get Involved! (Link: http://www.pluralsight.com/courses/get-involved)

Was macht ihr? Habt ihr Blogs? Oder seid ihr bei Twitter aktiv? Oder gar Softwareentwickler-Stammtisch im Oldenburger Münsterland (Link: http://softwareentwicklerstammtisch.de)? Schreibt mir gerne einen Kommentar (und geht damit einen weiteren Schritt in die richtige Richtung 🙂 )!

Veröffentlicht am 29.05.2015

In seinem Artikel beschreibt Peter Wayner sieben Dinge, die man von „älteren“ (=erfahreneren) Programmierern lernen kann: 7 timeless lessons of programming ‘graybeards’ | JavaWorld (Link: http://www.javaworld.com/article/2894748/core-java/7-timeless-lessons-of-programming-graybeards.html). Insbesondere die Tatsache, dass Speicher nicht unendlich verfügbar ist, kann ich nur unterstreichen.

Und passend zu diesem Thema: 4 Reasons to Employ Older Developers – Dice Insights (Link: http://insights.dice.com/2015/05/06/4-reasons-to-employ-older-developers/).

Veröffentlicht am 22.05.2015

About Eric Lippert (Link: http://ericlippert.com/about-eric-lippert/) hat eine sehr schöne Artikelserie mit dem Namen Wizards and warriors verfasst, in der er ein scheinbar kleines Problem darstellt, das sich eigentlich schnell mit den Mitteln der Objektorientierung lösen lassen sollte. Wie sich herausstellt, ist eine sinnvolle Lösung allerdings doch etwas schwieriger als erwartet.

Hier geht es zum ersten Artikel der Reihe: Wizards and warriors, part one | Fabulous adventures in coding (Link: http://ericlippert.com/2015/04/27/wizards-and-warriors-part-one/).

Veröffentlicht am 15.05.2015

Die Artikel sind schon etwas älter, aber immer wieder gut:

  • Falsehoods Programmers Believe About Names | Kalzumeus Software (Link: http://www.kalzumeus.com/2010/06/17/falsehoods-programmers-believe-about-names/) (auch interessant: die Kommentare zum Artikel)
  • Falsehoods programmers believe about addresses (Link: https://www.mjt.me.uk/posts/falsehoods-programmers-believe-about-addresses/)

Unglaublich, was es weltweit für verrückte Namen und Adressen gibt. Wenn man als Entwickler tatsächlich einmal eine wirklich internationale Software programmieren muss, hat man einige Ausnahmen zu berücksichtigen! Wie gut, dass es Unit-Tests gibt 😉

Veröffentlicht am 08.05.2015

GULP (Link: https://www.gulp.de) beantwortet aktuell in einer interessanten Marktstudie diese beiden Fragen:

Welche Programmiersprache bietet die besten Projektchancen für IT-Freelancer?
Womit erzielt man den höchsten Stundensatz?

Die kurze Antwort: Mit Java! Aber C# holt auf…

Hier geht’s zur Studie: Marktstudie: Java, C++ und C# (Link: https://www.gulp.de/presse/pressemitteilungen/marktstudie-java-c-plusplus-c-sharp.html).