Wilkening-Online Logo

Berichte von den C++ User-Treffen in Düsseldorf


Von Detlef Wilkening

Nächstes Treffen: Allgemeine Informationen:

C++ User-Treffen in Düsseldorf am 19.12.2018

Beim diesmaligen C++ User-Treffen in Düsseldorf gab es wie immer im Dezember das traditionelle C++ Weihnachts-Quiz von mir. 14 Interessierte waren gekommen um sich meinen neusten C++ Fragen zu stellen und ihr Unwissen ;-) unter Beweis zu stellen. Während ich das Quiz mitbrachte, hatten viele der anderen Anwesenden Kuchen und Kekse im Gepäck - so hatte jeder seinen Teil zum Abend beigetragen.

Auch diesmal hatte ich über das Jahr viele "schöne" Besonderheiten von C++ gesammelt - und daraus in den letzten Tagen ein wunderbares C++ Quiz geschnürt. Diesmal lag der Schwerpunkt meiner Fragen auf Default-Argumenten, auto, constexpr, Typen und Typefehlern, Überladen und Fragen zur Standardisierung. Und wie schon vor 2 Jahren hörte ich auch diesmal das Wispern aus dem Publikum "Wenn das compiliert, dann zweifele ich an der Sprache" - und natürlich compilierte es ;-) Wie immer hatten wir alle zwei Stunden lang viel Spaß mit den Untiefen von C++ - auch wenn einer der Anwesenden meinte, dies war mit all den Problemen und Fallen eher ein Anti-C++ Vortrag.

C++ User-Treffen in Düsseldorf am 18.04.2018

Beim diesmaligen C++ User-Treffen in Düsseldorf ging es um "cutting edge C++" und 14 C++ Entwickler waren gekommen um sich diesem Thema zu widmen. Jens Weller hatte den Vortrag vorbereitet und diskutierte die Probleme von Boost, die sich durch die Weiterentwicklung von C++ ergeben haben. Ein Teil der Bibliotheken von Boost ist nun obsolet - wie z.B. Shared-Ptr, Tuple, Optional, Variant, usw. Andere sind veraltet, da sie z.B. keine Referenz-Semantik oder andere moderne C++11/14/17 Sprachmittel unterstützen bzw. auch nicht nutzen - wie z.B. Flyweight, Serialisation, FlatMap, MPL, usw. Andere benötigen extrem moderne Compiler, und sind dadurch für viele Entwickler in der Praxis nicht nutzbar - wie z.B. Hana, HOF, mp11, usw. Und manche lassen sich nicht gut mit den Standard-Elementen koppeln, da sie auf den Boost-Elementen basieren die dann mit den neuen Standard Elementen in Konflikt treten - wie z.B. Asio bei den Shared-Pointern.

Wie kann Boost mit diesen Problemen umgehen, wie würde ein modernes Boost aussehen, und wie sieht es bei anderen C++ Bibliotheken aus? Diese Fragen stellte Jens den Anwesenden und versuchte sie auch zu beantworten. Jens stellte mögliche Lösungen vor, und scheute dabei auch nicht den Blick z.B. in die Qt Communitiy. Naturgemäß gibt es keine einfache und eindeutige Antwort auf solche Fragen, und so diskutierten die Anwesenden hinterher noch lange über dieses Thema. Auch hierbei zeigte es sich, dass die Meinungen und Ideen einen breiten Bereich abdecken und es keine einfache Antwort gibt.

Auch wenn der Abend sehr untechnisch war, so ist dies doch ein wichtiges Thema - nicht nur in der C++ Welt. Sobald es größere Mengen an altem Bestandscode gibt und/oder die Entwickler in der Praxis nicht immer direkt in die neuste Welt migrieren können - schon tauchen Probleme auf. Und wohl alle Entwickler waren hier von schon mal betroffen - also für jeden ein wichtiges Thema.

C++ User-Treffen in Düsseldorf am 20.12.2017

Beim diesmaligen C++ User-Treffen in Düsseldorf gab es wie immer im Dezember das traditionelle C++ Weihnachts-Quiz von mir. 14 Interessierte waren gekommen um sich meinen neusten C++ Fragen zu stellen und ihr Unwissen ;-) unter Beweis zu stellen. Während ich das Quiz mitbrachte, hatten viele der anderen Anwesenden Kuchen und Kekse im Gepäck - so hatte jeder seinen Teil zum Abend beigetragen.

Auch diesmal hatte ich über das Jahr viele "schöne" Besonderheiten von C++ gesammelt - und daraus in den letzten Tagen ein wunderbares C++ Quiz geschnürt. Diesmal lag einer meiner Schwerpunkte auf den Inkompatibilitäten zwischen C++03 und C++11. Es war immer wieder nett bei den Fragen zu sehen, wie die Gruppe um eine Antwort rang - sie fand - und dann mein Tipp (Achtung, es gibt zwei Antworten - eine für C++03 und eine für C++11) zum Aufstöhnen führte. Aber auch die Diskussionen bei den nicht so leichten Fragen oder die "Bedenken" bei scheinbar leichten Quelltexten war die Vorbereitung allemal wert.

Wie immer hatten wir alle zwei Stunden lang viel Spaß mit den Untiefen von C++, und auch ich habe diesmal etwas gelernt. Ich hatte eine Frage, deren Antwort ich natürlich kannte (mal wieder ein Unterschied zwischen C++03 und C++11) dabei - aber ich verstand die Ausgabe im C++03 Fall nicht wirklich. Die Diskussionen und die spontanen Nachforschungen klärten das Problem dann aber auf - danke vor allem an Daniel für seine Analyse.

C++ User-Treffen in Düsseldorf am 18.10.2017

Das diesmalige C++ User-Treffen in Düsseldorf hatte Jens Weller unter das Thema "C++ Buchclub" gestellt. Jeder sollte ein C++ Buch mitbringen, das er besonders gut oder schlecht findet bzw. das ihm in seiner Programmierer-Laufbahn besonders positiv aufgefallen ist oder ihm besonders gut geholfen hat. 13 C++ Entwickler hatten sich eingefunden um über C++ Bücher im Speziellen und C++ im Allgemeinen zu reden. Die eigentlich geplanten Lightning-Vorträge wurden auf den nächsten November Termin verschoben.

Da es keinen Vortrag gab, versammelten sich alle Teilnehmer um den großen Tisch im Chaosdorf - und viele fanden ihren Platz auf den gemütlichen Sofas, die sonst keinen guten Blick auf die Leinwand zulassen. Jens startete, und reihum stellten alle ein C++ Buch vor, bzw. zumindest ein Buch das sich um Programmieren drehte. Viele erzählten dabei auch mehr von ihrem C++ Werdegang und warum sie dieses Buch vorstellten. Daraus ergaben sich viele Gespräche und Diskussionen, die oft über C++ Bücher und C++ hinausgingen.

Auch wenn es diesmal nicht die geballte Informationsdichte eines Vortrags gab, und man vielleicht nicht soviel lernen konnte, so war es doch ein sehr netter und gemütlicher Abend - und man konnte viele Leute mal näher kennenlernen. Die vorgestellten Bücher waren die üblichen Verdächtigen: Stroustrup, Breymann und Koenig als Einsteigerlektüre, dann Alexander Andrescu, Scott Meyers, Herb Sutter und Nicolai Josuttis als die typischen Fortgeschrittenen Bücher. Es gab also keine wirklichen Überraschungen.

C++ User-Treffen in Düsseldorf am 19.07.2017

Für das diesmalige C++ User-Treffen im Chaosdorf in Düsseldorf war eigentlich ein Review einer kleineren Open-Source Bibliothek von Odin Holmes geplant - siehe letztes C++ User-Treffen - 10 Interssierte waren gekommen, um echten C++ Code zu reviewen. Statt eines Reviews stellt Odin dann aber seine Meta-Programming Libray "Kvasir" vor, und verglich diese mit u.a. mit der MPL und Hana von Boost und Brigand.

Odin führte Schritt für Schritt in die Features von Kvasir ein, indem er direkt im Compiler-Explorer kleine Programme eingab und man sofort das Compile-Ergebnis sehen konnte. So lernten alle Anwesenden die Fähigkeiten von Kvasir kennen, und wie einfach diese Bibliothek zu nutzen ist.

TMP zeichnet sich oft dadurch aus, dass die Programme "ewig" compilieren, bzw. im Extremfall sogar zu einem Compile-Abbruch führen da der Compiler an seine Grenzen bzgl. Memory oder Template-Instanziierung kommt. Kvasir zeichnet sich durch geringen Memory-Verbrauch und geringe Tiefe der Template-Instanziierung aus. Odin zeigte viele Tricks, die Kvasir intern nutzt um hier besser als z.B. gerade die MPL zu sein.

Viele Anwesende hatten schon selber mit TMP rumgespielt oder es in echten Projekten genutzt - und so gab es bei fast jedem Feature von Kvasir rege Diskussionen über die Umsetzung und die Schnittstelle. Selbst wenn nicht alle Entscheidungen von Odin allgemeine Zustimmung fanden - so war doch allen klar, dass Kvasir eine sehr schöne und elegante TMP Bibliothek ist, die sicher mehr als nur ein Anschauen wert ist.

C++ User-Treffen in Düsseldorf am 21.06.2017

Für das diesmalige C++ User-Treffen im Chaosdorf in Düsseldorf hatte Jens Weller einen Vortrag über "Was Boost und Qt voneinander lernen können" vorbereitet. 11 Interessierte waren gekommen um den Gedanken von Jens zu folgen und sie zu diskutieren. Wer einen technischen Vortrag erwartet hatte, wurde enttäuscht. Der Vortrag hatte zwar auch seinen technischen Aspekte, z.B. wenn es um die Frage nach der Nutzung der aktuellen C++ Standards ging - aber das Hauptanliegen von Jens waren mehr die Arbeiten der Communities.

Selbst wenn Boost extrem verbreitet und angesehen in der C++ Community ist, so hat Boost auch seine Probleme. Da es z.B. keinen reinen Boost-Blog gibt, oder einen Boost-Twitter-Kanal oder andere Medien - fehlt eine zielgerichtete Kommunikation zu den Nutzern. Natürlich enthält die Boost-Webseite eine Unmenge an Informationen - aber man muss sie erstmal finden. Beiden Communities gemeinsam ist, dass es mittlerweile kaum noch Vorträge zu Boost oder Qt gibt auf den typischen Konferenzen gibt - auch für die Meeting C++ 2017 gab es nur jeweils eine Einreichung, die aber wahrscheinlich beide nicht durchkommen werden. Für Qt stellt dies kein echtes Problem da, da es spezielle Qt Konferenzen gibt - aber bei Boost...

Ein anderes Thema von Jens war die Weiterentwicklungen der Bibliotheken. Hinter Qt steht eine kommerzielle Firma, die ein Interesse an Qt hat. Hinter Boost steht "nur" die Community - und so gibt es Boost Bibliotheken, die schon lange nicht mehr geupdatet wurden und bislang den Sprung zu z.B. C++11 nicht mitgemacht haben. Boost hat zwar einen Review-Prozess, der die hohe Qualität neuer Bibliotheken sichert, aber zum Teil kommen eigentlich gute Bibliotheken nicht durch den Prozess, da sie einen anderen Ansatz fahren als die Boost-Kerntruppe es gerne hätte. Boost liebt ja eh seine eigenen, oft auch eigenwilligen, Wege - man denke nur an das Build-Tool "bjam" was sonst kaum einer nutzt. Und der Review-Stau der eigentlich fertigen Bibliotheken im Incubator und der Sandbox sind ja schon fast legendär.

Von hier schlug Jens den Bogen zu einem alternativen Plan. Er möchte versuchen mit Hilfe von Reddit C++ Bibliotheken weniger formell zu reviewen und ihnen dann ein Zertifikat der Art "Meeting C++ Reviewed Lib" zu geben. Ohne das die Bibliotheken in das Boost.Design integriert und durch den formellen Boost-Review-Prozess müssen. Eine entsprechende Liste der "zertifizierten" Bibliotheken würde er auf "Meeting C++" hosten - und C++ Programmierer hätten dort eine schnellen Überblick über gute empfehlenswerte C++ Bibliotheken.

Der Vortrag führte zu vielen Diskussionen. Fast alle Anwesenden nutzen Boost - viele Qt. Und das Problem, welche C++ Bibliotheken gut sind, hat wohl jeder schon mal gehabt. Und so wurden die Anmerkungen und Ideen von Jens intensiv diskutiert - schon während des Vortrags, aber noch lange danach. Ob so ein Review auf Reddit funktioniert und ob ein solches Zertifikat angenommen wird - wir wußten es nicht. Aber der Abend war interessant und die Diskussionen erfrischend und spannend.

C++ User-Treffen in Düsseldorf am 17.05.2017

Für das diesmalige C++ User-Treffen im Chaosdorf in Düsseldorf hatte Sven Johannsen ein kleines Code-Dojo vorbereitet. 8 Interessierte waren gekommen, um ein gemeinsames praktisches Training in C++ abzuhalten.

Das Motto des Code-Dojo war wieder einmal Test-Driven-Development (TDD), d.h. der Zyklus zur Entwicklung sieht vor, dass ein Test geschrieben wird (das Ergebnis also rot ist, da der Test nicht bestanden wird), dann wird der Test durch eine entsprechende Implementierung zum Laufen gebracht (grün), und dann wird solange refaktorisiert, bis alle mit dem Zwischen-Stand zufrieden sind. Dank der vollständigen Test-Abdeckung ist ein Refactoring zum Glück immer sehr unproblematisch - sollte beim TDD aber trotzdem in kleinen Schritten ablaufen.

Als Aufgabe gab es diesmal einen speziellen String-Container: ein sequentieller Container ohne doppelte Einträge, bei dem die zuletzt "genutzten" Strings automatisch nach vorne verschoben werden. Außerdem sollte für den Zugriff auf die Elemente ein wahlfreier Zugriff zur Verfügung stehen, und sowohl "empty()" als auch "size()" Funktionen waren sinnvoll.

Jeweils für 5 Minuten gab es einen Piloten (der an der Tastatur ist und die Richtung bestimmt) und einen Co-Piloten, der den Piloten aktiv unterstützen soll und z.B. auf Probleme oder Fehler hinweist. Nach 5 Minuten wird dann der Co-Pilot zum Piloten, und ein neuer Co-Pilot kommt aus dem Publikum - während der alte Pilot wieder ins Publikum wechselt. Auf die Art und Weise kommen alle mal dran.

Da wir nur eine kleine Gruppe waren, und alle engagiert dabei waren, half nicht nur der Co-Pilot mit - eigentlich waren immer alle Anwesenden dabei und unterstützen den Piloten mit Ideen und Einsichten. Das Interessante sind hierbei oft die sich entwickelnden Diskussionen, wenn unterschiedliche Ansätze aufeinander treffen, oder jemand eine komplett neue Idee einbringt. Nach 51 Iterationen gab es dann ein Ergebnis, mit dem alle Anwesenden zufrieden waren, und das den Anforderungen entsprach.

C++ User-Treffen in Düsseldorf am 19.04.2017

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf gab es statt des angekündigten Vortrags von Jens Weller zwei kleinere Vorträge von Odin Holmes. 12 C++ Interessierte waren anwesend und konnten Neues zur Meta-Programmierung in C++ erfahren.

Der erste Vortrag drehte sich hierbei um Techniken aus dem Buch "Modern C++ Design" von Andrei Alexandrescu von 2003. Dieses Buch hat sicher viele C++ Programmierer beeinflußt und inspiriert - stellt Alexandrescu hier doch viele Techniken vor, die 2003 noch absolutes Neuland für die meisten C++ Programmierer waren. Odin beleuchtete die Techniken mit dem Wissen von heute: zum einen sind mittlerweile viele dieser Techniken heute ganz normal, und Andere können mit modernen C++11 und C++14 Mitteln viel einfacher umgesetzt werden.

Der zweite Vortrag ging dann auf moderne Meta-Programmierungs Techniken, die mit C++11, C++14 und zum Teil erst mit C++17 möglich werden - allen voran natürlich Variadic-Templates, aber auch constexpr und generische Lambdas spielten eine Rolle. Am Ende waren es zwei spannende Vorträge mit einer Reise durch die C++ Welt - für alle Anwesenden hat sich das Kommen sehr gelohnt.

C++ User-Treffen in Düsseldorf am 15.03.2017

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf gab es einen Vortrag von Kaveh Vahedipour über "Schnelle Numerik in C++". 13 C++ Programmierer waren gekommen, um sich mit auf eine Tour durch Lineare-Algebra und ihrer Umsetzung in C++ zu begeben.

Kaveh Vahedipours Hintergrund für diesen Vortrag war die NMR-Spektroskopie (auch Kernspinresonanzspektroskopie gennannt), und sein Anliegen war die korekte Verwendung der numerschen Verfahren bei der Rohdatenbearbeitung hin zur Erzeugung der entsprechenden Bilder.

Kaveh hielt einen sehr lebendige Vortrag und führte die Anwesenden erstmal in das Gebiet der NMR ein, indem er ein bißchen vom physikalischen Hintergrund erzählte. Dabei entwickelte er auch die Gleichung, die die Abhängigkeit vom Eingangsimpuls, der zu messenden Körper und dem gemessenen Signal beschrieb - eigentlich war die Gleichung viel einfacher als zumindest von mir erwartet. Da aber nur rund 1/30 der Information aufgenommen werden kann, müssen zusätzliche Bedingungen formuliert werden um den zu messenden Körper rekonstruieren zu können. Hier wird ausgenutzt, dass sich im zeitlichen Verlauf keine Sprünge in auftauchen dürfen - der Körper ändert sich ja nicht mitten in der Messung - und das das Kontrastmittel sich auch nur fließend verteilen kann.

Eine Botschaft des Vortrags, die Kaveh sehr wichtig war, war dass man den Verstand anstellen und benutzen solle. Man muss verstehen, was passiert und welche Auswirkungen und Grenzen die angewandeten Verfahren haben. Wenn z.B. die Messung viele kleine Signale und einen extrem großen Peak liefert - dann darf man nicht euklidisch normieren. Der Peak würde die Normierung dominieren - und die eigentlich Information in den kleinen Signalen wäre verschwunden. Hier ist der Peak der Ausreißer, der eleminiert werden muss.

Aufgrund der großen Rohdatenmengen (GByte sind hier eher die untere Grenze), und den sich ergebenden Matrizen der Größe über eine Milliarde spielt Speicher-Effizienz und Performance natürlich eine große Rolle - immerhin würde man im Idealfall Live-Bilder erzeugen können. Die von Kaveh entwickelte Numerik-Bibliothek kann die Berechnungen daher normal auf der CPU, unter Nutzung von SIMD-Befehlen, auf GPUs und auf Clustern ausführen. Hier ging es dann wirklich um C++. Das Target für die Berechnung z.B. setzte Kaveh als Template-Parameter um, er zeigte die Einbindung von SIMD-Befehlen mit Intrinsics, wies immer wieder die korrekte Nutzung von Alignment hin (die er mit einem eigenen Allokator und einem Template-Parameter beeinflußen konnte), und vieles mehr.

Unterm Strich war es ein sehr lebendiger und interessanter Vortrag, selbst wenn einzelne Teile des Vortrags im Detail kompliziert waren und vielleicht auch nicht jeder Anwesende immer allem exakt folgen konnte. Für mich war es mal wieder gut zu hören, wie einfach man solche Probleme mathematisch beschreiben kann, welche numerische Verfahren welche Probleme verursachen können, was alles Einfluß auf die Performance hat, und andere Dinge. Es war sicher für alle ein sehr interessanter und aufschlussreicher Abend. Hier noch die Links zu den Folien und mehr:

C++ User-Treffen in Düsseldorf am 15.02.2017

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf gab es einen einführenden Vortrag von Jörn Seger in die Bibliothek "Boost.Asio". 14 C++ Programmierer waren gekommen, um sich mit asynchroner Programmierung in C++ zu beschäftigen.

Zu Anfang berichtete Jörn, wo nach seiner Erfahrung die größten Schwierigkeiten von Einsteigern bei "Boost.Asio" liegen: im Wechsel des Programmier- und Gedankenmodells von Schleifen und Abfragen hin zu asynchronen Events. Darum gab er diesem Paradigmenwechsel eine entsprechenden Raum. Er stellte zuerst einmal vor, wie man Brot backt: man nimmt die korrekten Mengen an Mehl, Buttern und Eiern (mehr Zutaten wollte er der Einfachheit wegen nicht betrachten - es wurde also nur ein sehr "einfaches" Brot), mixt sie und stellt den Teig hinterher in den Backofen.

Wie würde sich dieser Vorgang nun ändern, wenn man dieses Brot im industriellen Maßstab herstellen will? Jörn stellte sich hier eine Maschine vor die Mehl herstellt, eine Weitere für Butter und eine Dritte für Eier. Außerdem gab es auch entsprechende industrielle Mixer und Backofen. Alle 5 Maschinen wurden jeweils von einer Person bedient, die sich um die Maschine und ihr jeweiliges Produkt kümmert. Bei diesem Organisations-Modell konnte man schnell sehen, dass das Bedienpersonal quasi nur wartet und es Synchronisationsprobleme bei den Schnittstellen gibt - also keine wirklich gute und effiziente Lösung. In einem Software-Programm wären die Personen wartende Threads - nicht gut.

Statt dessen wäre es viel einfacher wenn der Ablauf regel-basiert abläuft, z.B.: "Wenn die Mehl-Maschine fertig ist, fülle das entstandene Mehl in den Mixer". Eine Person würde reichen, die dann nur noch auf die Events der Maschinen nach einfachen Regeln reagiert - und dann wieder auf das nächste Event wartet. Und genau das macht "Boost.Asio": Asio triggert einfach nur bei Ereignissen Aktionen an. Ereignisse können hierbei Timer-Events, Signals oder eben I/O Operationen wie Netzwerk-Kommunikati sein. Man benötigt hierfür nur einen Asio "io_service" und die entsprechenden Ereignis-Definitionen mit ihren Aktionen - und fertig.

Als erstes Beispiel stellte Jörn dann die Umsetzung seiner Brot-Back-Industrie als C++ Programm mit Asio vor. Timer simulierten die arbeitenden Maschinen und Konsolen-Ausgaben die Zwischen-Schritte und -Ergebnisse. Das Programm selber war sehr einfach, und so konnte man sehr gut sehen wie Asio die asynchrone Struktur des Programms bestimmte, und wie einfach der Code wurde. Ein zweites Beispiel von Jörn bestand aus 120 Zeilen C++ Code und war ein Konsolen-Chat Programm mit Server und Clients, das sowohl direkte Kommunikation als auch Broadcast Messages unterstützte. Die Ereignisse waren hier nicht mehr Timer Events, sondern eben asynchrone Netzwerk-Kommunikation (Jön hatte hier UDP gewählt) - eine der Domainen von Boost.Asio.

Am Ende ging Jörn noch kurz auf eher fortgeschrittene Themen wie Multithreading mit Boost.Asio oder Signals ein. Und so war der Abend für alle ein echter Gewinn. Asio Anfänger bekamen einen guten Einstieg in das Konzept der asynchronen Programmierung mit Boost.Asio - die Experten diskutierten mit Jörn die eher tieferen Themen und konnten so auch ihr Wissen austauschen und vertiefen.

C++ User-Treffen in Düsseldorf am 18.01.2017

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf gab es einen Vortrag, der nur sekundär mit C++ zu tun hatte. Mirco Müller wollte zeigen, ob man mit händisch geschriebenem Assembler Code von der Performance her die C++ Compiler schlagen kann oder nicht. Immerhin 13 Leute waren gekommen, um diesmal nicht nur über C++ zu reden, sondern sich mal in die Tiefen der Maschine zu begeben.

Der Abend startete mit einer kuren Motivation von Mirco, warum heute überhaupt noch Assembler machen sollte. Neben dem möglichen Performance-Gewinn sah er hier stark das Verständnis, was in der Maschine passiert - um z.B. Performance-Flaschenhälse in den eingenen Programmen oder Viren oder Sicherheitslücken besser verstehen und begegnen zu können - dazu später noch mehr. Außerdem gibt es natürlich immer noch Plattformen - vielleicht mit dem Internet-of-Things (IoT - oder stand die Abkürzung für &qout;Internet-of-Trouble&qout;?) auch immer mehr - bei denen es auf das letzte Byte und Taktzyklus ankommt.

Danach führte Mirco kurz in x86 Assembler ein - zeigte die beiden x86 Dialekte (Intel & AT&T), stellte die x86 Register mit ihrer Historie vor, führte Aufruf-Konventionen ein, und vieles mehr. Danach waren die Anwesenden natürlich noch keine Assembler Experten - aber einen ersten Eindruck von x86 Assembler hatte wohl jeder gewonnen. Damit war endlich die Zeit für die konkreten Beispiele von Mirco gekommen. Er hatte die Veränderung der Helligkeit von Bildern, die Simulation der Ausbreitung von Flüssigkeitstropfen in einer anderen Flüssigkeit, und das Unschärfen von Bildern mit dem "Blur-Box" Verfahren im Programm. Die ersten beiden Beispiele hatte er in C++ und Assembler umgesetzt - beim dritten Beispiel lief nur die C++ Variante fehlerfrei. Die Assembler Variante war noch nicht fertig und liefert bislang nur komisch blau-grünes Ergebnis-Bild.

Alle Beispiele waren sehr rechenintensive Verfahren, bei denen sich daher die Verwendung von SIMD Operationen stark lohnte. Wenn der Compilerdiese nicht von sich aus benutzt, dann war der händische Assembler Code problemlos schneller. Nutzt der Compiler diese, dann waren die Unterschiede nicht so groß. Zum Teil gewann der GCC 6.1 Compiler, zum Teil der Clang 3.8, zum Teil der Assembler Code von Mirco. In der Gesamtheit war das Fazit hier, dass moderne Compiler meist einen verdammt guten Job machen und sehr guten Code erzeugen.

Aber Mirco erzählte auch, dass er bei seinen Vorbereitungen einmal die Compiler extrem geschlagen hatte - seine 19 Instruktionen waren viel schneller als die fast 100 Intruktionen, die die Compiler erzeugten. Aber bei der Analyse fiel ihm dann auf, dass die Compiler extrem viele Konvertierungen durchführen mussten - und das machte ihn stutzig. Ein tiefere Analyse führte dann zu einem Problem in seinem C++ Code, der Wandlung zwischen "float" und "double" erzwang. Nachdem er dies im C++ Code beseitigt hatte war auch der Compiler Code vergleichbar seinem händisch Erzeugten. Überhaupt war dies ein typisches Szenario, von dem viele Teilnehmer berichteten - das Verständnis des erzeugten Assembler Codes hilft sehr häufig die Flaschenhälse im geschriebenen C++ Code zu finden und zu verstehen.

Der Abend lebte - neben dem tollen Vortrag - mal wieder sehr stark von den Diskussionen. Immer wieder wurde Mirco unterbrochen, und die Anwesenden steuerten ihre Erfahrungen und ihr Wissen bei. Gerade das Verständnis von Assembler für besseren C++ Code wurde immer wieder hervorgehoben und mit vielen Beispielen belegt. Auch aus dem Embedded Umfeld wurde immer wieder berichtet, und manch einer der Anwesenden steuerte auch Erfahrungen und Wissen aus dem Numerik-Umfeld und zu SIMD bei. Unterm Strich ist es für alle wieder ein gelungener und interessanter Abend gewesen. Hier finden sich Folien des Abends als PDF. Außerdem hat Mirco das fehlende Live-Coding als Video auf YouTube zur Verfügung gestellt.

C++ User-Treffen in Düsseldorf am 21.12.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf gab es natürlich wieder das traditionelle C++ Weihnachts-Quiz von mir. 14 Interessierte waren gekommen und hatten passend zur Weihnachtszeit viele Kekse und Lebkuchen mitgebracht. So war auch für das leibliche Wohl gesorgt - und alle ausser mir konnten sich in Ruhe zurücklehnen und sich ganz den Fragen widmen.

Ich hatte wieder viele neue Fragen aus den Untiefen von C++ vorbereitet. Letztlich bin ich jedesmal erstaunt, dass ich im Laufe des Jahres soviele neue Fragen für das Quiz zusammenbekomme, wo ich doch eigentlich schon alle Untiefen abgedeckt hatte. Aber auch dieses Jahr war es erstaunlicherweise (oder erschreckenderweise) kein Problem. Das Lesen vieler Blogs, das Hören vieler Vorträge auf Konferenzen oder User-Treffen, aber auch die Diskussionen mit vielen Leuten hatten wieder ein großes Repertoire an Fragen zusammenkommen lassen. Auf der anderen Seite ist mir auch dieses Jahr wieder klar geworden, dass man Programmier-Sprachen bloss nicht nach solchen Quiz beurteilen sollte. Letzlich gibt es zwar viele Untiefen und Details in C++ - ich habe aber in der Praxis mit keiner davon je zutun gehabt. Wer halbwegs normalen Code schreibt merkt nichts von diesen Details. Manchmal habe ich den Eindruck, man hat diese Spezialitäten nur für mich und mein Quiz in den Standard integriert...

Zurück zum eigentlichen Quiz: diesmal hatte ich u.a. einige Fragen vorbereitet, in denen es um die feinen Unterschiede zwischen C und C++ ging - hier merkte man sofort, wer der Anwesenden schon mal C programmiert hatte und wer nur C++ kannte. Viele andere Fragen nutzten seltsame Kombinationen von Sprach-Features und fragten ob der Code überhaupt compiliert, und wenn ja ob er wohldefiniert ist oder unspezifisches und gar undefiniertes Verhalten zeigt, und was er wohl ausgibt - z.B. kann man sogenannte "Voldemore-Typen" aus einer Funktion zurückgeben und vom Aufrufer nutzen? Meine persönlichen Lieblingsfragen drehten sich dieses Jahr aber um "interessante" Effekte bei den Compiler-Optimierungen. So kann eine ungeschickte Kombination von Optimierungen dazu führen, dass ein Programm an einer Code-Zeile mit einem Null-Zeiger crasht, obwohl direkt davor eine Abfrage auf "nullptr" durchgeführt wird.

C++ User-Treffen in Düsseldorf am 16.11.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren 14 Leute anwesend, und konnten einen recht abwechslungsreichen Abend erleben. Während sonst eigentlich immer ein großer Vortrag in Düsseldorf stattfindet - gab es diesmal 4 kleinere Events.

Der Abend startete mit einem Vortrag von Klaus Wittlich über numerische Probleme in C++. Hierbei konzentrierte er sich vor allem auf zwei Themen: die elementaren mathematischen Datentypen und Zufallszahlen. Bei den elementaren mathematischen Datentypen zeigte er zuerst auf, wie häufig mathematische Operationen die Grenzen (Auflösung bzw. Umfang) der Datentypen verletzen - danach welche grundlegenden mathematischen Gesetze (z.B. Kommutativ-Gesetz, oder das Vorhandensein eines neutralen Elements) bei welchen Typen verletzt sind. Aus diesen Einschränkungen ergeben sich in der Praxis eine Menge Probleme - so viele, dass man sich unwillkürlich fragt, warum doch meistens alles klappt. Im zweiten Teil focusierte Klaus auf die Zufallszahlen in C++11 - er stellt die Zufallszahlen-Generatoren mit ihren Stärken und Schwächen vor, und danach die Zufallszahlen-Distributionen mit ihren Abbildungen. Für jemanden wie mich, der sich immer für Mathe interessiert hat, aber selten mathematische Dinge programmieren musste - war es ein sehr sehr interessanter Vortrag.

Nach Klaus übernahm Sven Johannsen die Vortrags-Reihe. Er stellte das Micro-Performance Test-Framework von Google vor. Da er diesen Vortrag schon im Juli 2016 in Aachen gehalten hat, verweise ich hier nur auf den Bericht.

Der dritte Vortrag war von mir und stellte neben einigen kleinern Hinweisen für gute Funktions-Signaturen primär das sogenannte Builder-Idiom in C++ vor. Es kann Code viel lesbarer und wartbarer machen, wenn Funktionen viele Parameter bekommen. Neben dem klassischen Builder-Idiom mit Daten-Klasse hatte ich weitere Implementierungen mit Variadic-Templates und user-defined Literals im Gepäck. (Nachtrag 31.11.2016: auf der Meeting C++ in Berlin habe ich mittlerweile 3 weitere Varianten kennen gelernt, wie man in C++ das Builder-Idiom implementieren kann. Ich werde den Vortrag wohl aufbohren und nochmal halten müssen...).

Der letzte Vortrag von Sascha Atrops war kein normaler Vortrag. Statt dessen hatte Sascha realen Code dabei, an dem er zuhause entwickelt. In diesem gibt es u.a. ein n-dimensionle Punkte-Klasse, als Klassen-Template implementiert. Und er suchte hierbei nach einer Lösung, seine Konstruktoren allgemein für n Dimensionen zu implementieren - ohne sie für jede Dimension spezialisieren zu müssen. Sascha erklärte uns seine Probleme, und dass er schon an Variadic-Templates als Lösung gedacht hatte - sie aber nicht zum Compilieren gebracht hatte. Das war dann unsere Aufgabe, die wir mit geballtem C++ Know-How schnell gelöst hatten. Nun hat Sascha ein Implementierung für alle Dimensionen.

C++ User-Treffen in Düsseldorf am 19.10.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf habe ich einen einführenden Vortrag über "Variadic-Templates und Parameter-Packs" gehalten. Im ersten Augenblick mag man denken, dass das kein abendfüllendes Thema ist, denn die "Ellipse" (die drei Punkte...) definieren einfach eine beliebige Parameter-Anzahl, und wiederum mit der Ellipse können die Parameter beim weiterreichen dann wieder ausgepackt werden - fertig. Ist das einen Abend in Düsseldorf wert?

Aber wie so oft wäre das zu kurz gedacht. In Wirklichkeit steckt noch viel mehr hinter "Variadic-Templates" und "Parameter-Packs". Immerhin 10 C++ Interessierte wussten das, und waren gekommen um den Vortrag zu hören und zu diskutieren.

Doch zuerst habe ich motiviert, warum man Variadic-Templates in C++11 eingeführt hat, welche Probleme sie lösen. Dann habe ich einige Anwendungen gezeigt, bei den die Parameter wirklich nur so einfach durchgereicht werden. Aber schon bei einem Variadic-Klassen-Template, bei dem die Parameter "nur" an einen "vector<tuple<Ts...>>" durchgereicht wurden, gab es einige trickreiche Probleme zu lösen. Wie - z.B. - greift man dann zur Laufzeit mit Laufzeit-Indices auf die Zellen-Elemente zu? Für den Vector kein Problem - aber das Tuple erwartet Compile-Zeit Konstanten! Den Zugriff zur Compile-Zeit auszurollen war hier die Lösung. Bei der Implementierung eines eigenen Tuples waren dann die nächsten Griffe in die C++ Trickkiste notwendig: Spezialisierungen, Typen abtrennen, und Namenskonflikte durch Vererbung in mehrere Ebenen legen waren hier angesagt. Und so ging es weiter über sizeof... bis hin zur Verbindung der Parameter-Expansionen mit C++14 Integer-Sequenzen, oder dem Ableiten von vielen Mixin-Klassen auf einmal.

Alle Themen wurden von den Anwesenden ausführlich diskutiert und besprochen, und viele konnten eigene Erfahrungen bzw. andere Aspekte beisteuern. Unterm Strich wurde allen klar, dass man mit Variadic-Templates mehr machen kann, als man zuerst erwartet, und dass sie ein wirklich mächtiges und hilfreiches Werkzeug in C++ sind.

C++ User-Treffen in Düsseldorf am 21.09.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf ging es relativ mathematisch zu. Das Thema von Timo Stöcker waren Reed-Solomon-Codes und ihre effiziente Implementierung in C++. Leider waren nur 9 C++ Interessierte ins Chaosdorf gekommen, um sich mit Fehlerkorrekturen und "constexpr" zu beschäeftigen.

Zuerst stellte Timo aber seine Motiviation vor - es ging ihm nämlich gar nicht um Fehler-Korrekturen, was ja die eigentliche fachliche Domäne der Reed-Solomon-Codes ist - sondern um die Erzeugung von möglichst unterschiedlichen Identifiern fester Länge, wie man sie z.B. von YouTube-Links oder URL-Shortenern kennt. Da die Fehlerkorrektur von Reed-Solomon-Codes aber darauf beruht, den Abstand von Codes zu maximieren - kann man mit ihnen eben auch möglichst unterschiedliche Identifier erzeugen.

Nachdem Timo kurz das Fehlerkorrektur-Verfahren mit Reed-Solomon-Codes, das z.B. auf CDs, im DVB Standard oder in Mobilfunk-Standards Anwendung findet, vorgestellt hatte - ging es mehr ans Eingemachte. Mathematisch basieren Reed-Solomon-Codes auf endlichen Körpern, und so mussten die Anwesenden ihre LA1 Kenntnisse rauskramen, um Timo bei seinen Erklärungen über Polynome und Körpern folgen zu können.

Als es dann an die effiziente Implementierung in C++ ging, konnten alle nicht so mathematisch-affinen Anwesenden aufatmen und wieder voll dabei sein. Timo stellte vor, wie er seine F32 Körper-Polynome mit 5 Bit Mustern in C++ codierte, und wie er die definierten mathematischen Operationen ausprogrammierte. Wichtig war ihm hierbei, dass alle Operationen prinzipiell schon zur Compile-Zeit auswertbar sind - d.h. setzte er überall "constexpr" ein und berichtete von seinen Erfahrungen und Problemen (insbesondere mit "std::array") bei der Umsetzung. Einige mathematische Operationen konnte er auf Lookup-Tabellen abbilden, die dann natürlich auch mit seinen "constexpr" Operationen schon zur Compile-Zeit erzeugt werden konnten - und so sehr effizient sind.

Am Ende zeigte uns Timo die erzeugten Identifier - wie sie am Anfang extrem unterschiedlich sind und im Laufe der Generierung immer ähnlicher werden - genau wie gewünscht. Der von ihm gewählte F32 Körper kann rund eine Millarde Identifier generieren, wobei 32 eine max. Unähnlichkeit aufweisen, weitere 1024 eine fast optimale Unähnlichkeit, usw. Unterm Strich war es ein sehr interessanter Abend mit vielen Fragen und Diskussionen, der unser Wissen über Fehler-Korrekturen, endliche Körper und Compile-Zeit Programmierung klar erweitert hat.

C++ User-Treffen in Düsseldorf am 17.08.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf war Nicolai Josuttis mit einem Vortrag über die "Mythen und Geheimnisse der Move-Semantik" zu Besuch. 17 C++ Programmierer waren ins Chaosdorf gekommen, um sich aus erster Hand über dieses Themen zu informieren.

Den Bericht kann ich diesmal sehr einfach gestalten - Nico hatte den gleichen Vortrag am 22. März 2016 schon in Köln auf dem C++ User-Treffen gehalten - und mein Bericht von damals paßt auch halbwegs auf diesen Abend. In einigen Details war der Vortrag gegenüber Köln zwar verändert (verbessert) - aber im Großen und Ganzen war es der gleiche Vortrag. Im Köln Bericht gibt es auch einen Link auf die Folien des Vortrags von Köln - sollte Nico die neue Version aus Düsseldorf auch noch veröffentlichen, dann werde ich den Link hier noch eintragen.

C++ User-Treffen in Düsseldorf am 20.07.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf stellte Jens Weller eines seiner aktuellen C++ Projekte vor und zeigte uns als Teil des Projekts die Bearbeitung und Darstellung von Graphen mit Hilfe der Libraries "Boost.Graph & QGraphicsView". 10 C++ Programmierer waren gekommen um mehr über Graphen zu erfahren.

Der Abend begann dann mit einer Einführung in Boost.Graph (BGL). Da das Interface der BGL an einigen Stellen unintuitiv ist, stellte Jens erstmal einige Grundkonzepte der BGL vor - z.B. wie überhaupt Ecken und Kanten definiert werden und dann auf ihnen gearbeitet werden kann. Besonders ging er hierbei auf die Layout-Algorithmen "random", "circle", "KamadaKawaiSpring", "FruchtermanReingold" und "GursoyAtun" ein, da Layouting ein wichtiger Teil seines Projekts ist.

Danach ging es um die Frage der Darstellung der Graphen - hier verwendet Jens die C++ Bibliothek Qt, und in diesem Fall besonders die "QML" und den "QGraphicsView". Nach einer allgemeinen Erläuterung seines Vorgehensweise stieg er dann detailliert in den Code ein und zeigte die entsprechenden Klassen und Funktionen. Dabei wies er immer wieder auf Stärken aber auch Schwächen seines Ansatzes hin, die sich zum Teil auch durch die verwendeten Techniken ergaben.

Am Ende des Vortrags gab es noch manche Frage, die Jens gerne beantwortete. Im Laufe dieser Diskussion wechselte der Abend dann immer mehr in den gemütlichen Teil über, bei dem sich die Anwesenden über ihre C++ Themen austauschten - und auch andere Themen nicht fern blieben.

C++ User-Treffen in Düsseldorf am 15.06.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf hatte Frank Birbacher 2 Vorträge im Gepäck dabei - "Argument Dependent Lookup" und "Monaden" waren seine Themen. 16 C++ Entwickler hatten sich entschlossen auf die Fußball EM zu verzichten und sich statt dessen diesen Herausforderungen zu stellen.

Der Abend begann mit dem Vortrag über "Argument Dependent Lookup" - auch "ADL" oder "Koenig-Lookup" genannt. ADL löst ein Problem, von dem viele C++ Programmierer nicht mal wissen, dass es existiert, denn magisch funktioniert fast immer alles so wie man möchte - ADL sei Dank.

Funktionen werden in C++ nicht nur im aktuellen Kontext, sondern auch u.a. in den Kontexten (meist Namespaces) der Argumente gesucht. Daher funktioniert eine einfache Ausgabe wie "std::cout << 42;" überhaupt - denn der benötigte Operator stammt aus dem Namespace "std" - und in dem befindet sich diese Anweisung sicher nicht. Der Compiler findet den Operator aber, da er eben auch in den Kontexten (hier "std") der Argumente (hier "std::cout") sucht.

Frank erklärte nachvollziehbar das Problem und dann die Lösung und listete auf, wo der Compiler die entsprechnde Symbole sucht. Außerdem wies er noch auf ein wichtiges Idiom in generischem Code hin, um z.B. die Nutzung von spezifischen "swap" Funktionen mit dem "std::swap" in jeder Situation korrekt zu ermöglichen - allein durch diese 15 Minuten hätte sich der Abend sicher schon für viele Programmierer gelohnt.

Dann wandte sich Frank dem Haupt-Thema des Abends zu: "Monaden". Monaden (die hauptsächlich in Haskell eingesetzt werden) sind ein sagen-umwobenes Thema in der Informatik, denn nur wenige Programmierer haben sie wirklich verstanden - und die meisten Programmierer benötigen Jahre um sie zu verstehen. Nicht umsonst gibt es im Internet 1000-de von Tutorials zu Monaden - und die Legende sagt: dass irgendwann nach Jahren Programmierer das Konzept "Monade" verstehen, sich dann fragen was daran denn so schwierig war, und dann sofort ein weiteres Tutorial zu Monaden schreiben damit endlich alle Programmierer ganz leicht und schnell verstehen was eine Monade ist. Man sieht - Frank hatte sich eine echte Herausforderung vorgenommen...

Frank startete, indem er etwas ganz einfaches (eine Funktion die eine übergebene Zahl mit sich selbst addierte und das Ergebnis zurückgab) Schritt für Schritt ganz kompliziert machte. Am Schluß addierte die Funktion zwar immer noch nur den Parameter mit sich selbst - benötigte dafür aber nun 2 weitere Template-Funktionen (mit Template-Template-Parametern) und intern noch zwei weitere Lambda-Ausdrücke. Der Trick bestand darin, dass der Template-Template-Parameter der Template-Funktionen nicht in unserer Funktions-Implementierung auftauchte, sondern nur noch in der Signatur - und dieser Template-Template-Parameter war jetzt die Monade unserer Funktion. Unser toller Algorithmus (Addition zweier Zahlen) galt nun als "monadisiert". Zum "Trost" zeigte Frank uns noch die gleiche komplexe Funktionalität in Haskell, wo sie syntaktisch viel einfacher ist.

Als nächstes stellte Frank konkrete Monaden bereit - und er begann mit der Identität: einer einfachen Abbildung von x auf x. Damit addierte unsere Funktion weiterhin den Parameter mit sich selbst und gab das Ergebnis zurück. Aber Frank konnte auch andere Monaden erstellen - z.B. eine Listen-Monade, die jetzt unserer Funktion einen Listen-Parameter (z.B. vector) aufdrückte und sie alle Additions-Permutationen über den Vektor als Ergebnis zurückliefern ließ. Eine Optional-Manade brachte unsere Funktion dazu, den Berechnungs-Vorgang unter Umständen mittendrin abzubrechen. Eine Writer-Monade ermöglichte Ausgaben statt der Berechnung, und eine Reader-Monade konnte für Eingaben sorgen. Mit einer Monade konnte man nun unsere Funktion ganz andere Dinge machen lassen, als vorher vorgesehen war. Ein monadischer Algorithmus ist also in der Lage sein Verhalten in einem sehr starken Maße zu ändern.

Am Ende des Abends stellte Frank als letztes großes Hightlight noch eine Continuation-Monade vor, mit - so drückte es Frank aus - 5-fachem Schwierigkeitsgrad. Danach war es einiges nach 23:00 Uhr - u.a. weil wohl jede Folie lang und breit diskutiert wurde. Alle Anwesenden hatten sich vorgenommen, sich dem Thema Monaden zu stellen und so versuchten wir alle jede Folie wirklich zu verstehen. Und so musste Frank immer wieder zurück springen, viele Fragen beantworten, lange Diskussionen moderieren und uns alle immer wieder abholen. Am Ende war es ein langer anstrengender Abend gewesen - aber auch inspirierend. Wie erfolgreich Frank war? Lassen wir uns überraschen wieviele neue Monaden-Tutorial in den nächsten Tagen im Netz auftauchen...

C++ User-Treffen in Düsseldorf am 18.05.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf entwickelte Sven Johannsen einen "vector from scratch". Das Thema versprach einen interessanten Abend, und so waren 17 C++ Entwickler nach Düsseldorf ins Chaosdorf gekommen - immerhin 11 aus Aachen und 3 aus Köln. Liebe Düsseldorfer C++ Entwickler - wo wart ihr denn?

Sven begann seinen Vektor mit einer Implementierung mit 3 Element-Zeigern - auf den Puffer, das Ende des Puffers (bzw. ein Element danach) und das erste nicht mehr vorhandene Element im Puffer. Mit diesem einfachen Ansatz konnte er viele Anforderungen des Standards problemlos umsetzen - wie er uns für eine Menge Funktionen zeigte. Aber es tauchten auch die ersten Probleme auf - ein "clear()" würde z.B. für mehrfache Destruktor Aufrufe sorgen - einmal beim "clear()" selber, aber auch ein weiters Mal noch beim Zerstören des Vektors - und das darf natürlich nicht sein.

Die Lösung sind Allokatoren, die neben der Möglichkeit einer alternativen Speicherverwaltung sich um "rohen Speicher" kümmern, und damit die doppelten Destruktor Aufrufe eleminieren. Sven führte detailliert in die Allokatoren ein, und zeigte einige interessante Aspekte der Implementierungen auf.

Das nächste Thema war Exception-Sicherheit und die Move-Semantik. Wie können die einzelnen Funktionen des Vektors exception-sicher und effizient umgesetzt werden - gerade die Reallokation ist hier ein schönes Beispiel für ein eigentlich ganz einfaches Problem, das schon einigen Gehirn-Schmalz für die Lösung erfordert. Aber auch andere Funktionen sind hier echte Herausforderungen - denen wir uns mit Sven's Hilfe stellen konnten und meisterten.

Letztes großes Thema waren dann die Iteratoren, die natürlich zu einem Container dazugehören. Auch diese bringen einige Herausforderungen mit sich. Und wieder erklärte Sven spannend die anstehenden Probleme und mögliche Lösungen.

Schon während des Vortrags - aber auch hinterher - waren die einzelnen Themen stark diskutiert worden. Viele Detail-Fragen waren aufgetaucht, und konnten dann von Sven und der Gruppe zufriedenstellend beantwortet werden - selbst wenn einige Mal auch der Standard zu Rate gezogen wurde. Unterm Strich war es ein super-interessanter Abend mit einem tollen Vortrag und lebhaften Diskussionen. Und bei mir blieb mal wieder die Erkenntnis das auch eine scheinbar so simple alltägliche Klasse wie ein "vector" im Detail viele Herausforderungen enthält, die man zuerst gar nicht so sieht. Man gut dass es C++ User-Treffen gibt um all dieses Zeug zu Lernen und zu Verstehen.

C++ User-Treffen in Düsseldorf am 20.04.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf stellte Jens Weller seine "Generic JSON" Arbeiten vor. Leider waren nur 6 Interessierte gekommen, aber so konnte der Vortrag in einem sehr kleinen Kreis viele Diskussionen zulassen.

Zuerst stellte Jens grob sein aktuelles C++ Projekt vor - die Entwicklung eines eigenen CM-Systems für seine eigene Webseite "Meeting C++". Existierende CM-Systeme konnten entweder seinen Workflow nicht gut genug abbilden, führten zu wiederkehrenden Migrations-Problemen, oder gefielen im einfach nicht. Und so entschied Jens sich einfach ein eigenes CMS in C++ zu entwicklen - sicher auch ein bißchen als Hobby und Interesse am C++ Programmieren.

Danach ging er auf den Tool-Stack ein, auf den er in seinem CMS aufbaute - u.a. Standard C++, Boost und Qt - und berichtete hier von einige Themen und Lösungen, z.B. bei der Serialisierung. Ausführlicher stellte er dann boostache als eine C++ Implementierung von mustache (eine Text-Template Sprache) vor - ein weiteres Framework in seinem Tool-Stack.

Dann wechselte er zum eigentlich Thema "Generic JSON". Für sein CMS musste er JSON Dateien lesen und schreiben - und hatte sich hierfür verschiedenste C++ JSON Bibliotheken angeschaut, u.a. auch unter dem Gesichtspunkt Performance. Dabei kam er auf die Idee, vier der für ihn interessantesten C++ JSON Bibliotheken hinter einer einheitlichen Schnittstelle zu verbergen, so dass ein Anwender die eigentliche JSON Bibliothek schnell und einfach austauschen kann - "Generic JSON" eben. Nachdem er sein Ziel high-level dargestellt hatte, ging es dann in den Code. Dort zeigte Jens wie er mit Hilfe von Templates, enable_if, declspec und anderen C++ Mechanismen Code geschrieben hatte, der sich zur Compile-Zeit von ganz alleine an die verwendete C++ JSON Bibliothek anpaßt.

Noch ist seine "Generic JSON" in der Entwicklung, aber sobald eine erste Version in Zukunft existiert will Jens sie auf Github als Open-Source Lib zur Verfügung stellen. Aber nicht nur deshalb, sondern auch aufgrund der interessanten Einblicke in den Template-Code und der Diskussionen um generische Schnittstellen war es ein gelungener Abend. Und er zeigt, dass wohl jeder mit einem C++ Projekt das Basis-Material für einen interessanten Vortrag besitzt.

C++ User-Treffen in Düsseldorf am 16.03.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf hatte ich mal wieder den Abend übernommen: "Koroutinen" sollten das Thema sein. 13 C++ Programmierer waren gekommen, um mehr über dieses für viele unbekannte Thema zu erfahren. Genau genommen wollte ich auch nicht nur über "Koroutinen" reden, sondern hatte etwas mehr im Gepäck: "Koroutinen, resumable functions, Generatoren & Fibers" hatte ich meinen Vortrag genannt. In der Ankündigung hatte ich häufig nur von "Eine Einführung in die Grundlagen von Koroutinen" gesprochen. Dies war Absicht gewesen - ich hatte schon mehrere abgedrehte Koroutinen-Vorträge gehört die mich nach wenigen Minuten abgehängt hatten. So etwas wollte ich nicht machen - ich wollte die Zuhörer nicht verlieren. Dadurch war der Rahmen natürlich eingeschränkt, und ich konnte abgedrehte Themen nicht ansprechen - aber das war ja auch nicht meine Intention.

So startete ich mit einem großen einführenden Kapitel in das Thema. Besprach kurz die Historie, wer wann Koroutinen eingeführt hatte, und welche Sprachen sie schon lange unterstützen. Simula 67 und Modula 2 waren wohl die ersten Sprachen mit Koroutinen gewesen, mittlerweile sind sie aber auch in vielen anderen Sprachen vorhanden - wie z.B. Go, Lua, Ruby, Python und viele mehr. Viele Sprachen stellen das Feature auch als Bibliothek zur Verfügung, oder stellen mit Sprachmitteln wie Fibers, Closures oder Continuations Möglichkeiten bereit die vergleichbar zu Koroutinen sind. C++ enthält Koroutinen bislang auch nicht als Teil des ISO Standards, dies wird sich leider auch mit C++17 nicht ändern - wir müssen hiermit wohl auf C++20 warten. Aber Koroutinen-Bibliotheken gibt es einige.

Dann ging es mehr ins Detail. Mit Boost.Coroutine stellte ich eine konkrete Koroutinen-Bibliothek für C++ vor, und führte mit vielen sehr einfachen Beispielen in die Nutzung von Koroutinen ein: Aufbau asymmetrischer Koroutinen, Übergabe von Werten von Koroutinen oder an sie, Behandlung von Fehlern, Aufbau symmetrischer Koroutinen, Lambdas als Koroutinen, das Iterator-Interface asymmetrischer Koroutinen, und vieles mehr. Nach den Grundlagen kam die Praxis in Form einiger Beispiele: Abarbeitung möglicher Züge bei Strategiespielen, Mergen von sortierten Mengen, Layouten von Wörtern auf der Konsole und die Iteration rekursiver Strukturen. Hier konnte man sehen, wie vorteilhaft die Nutzung von Koroutinen bei alltäglichen Problemen sein kann.

Als Abschluß gab es noch zwei recht kurze Kapitel über "Koroutinen & Multithreading" und "Fibers". Zuerst konnte ich hier die Vorteile von Koroutinen mit kooperativem Scheduling gegenüber normalen Threading mit preemptiven Scheduling anpreisen und einige Anwendungs-Szenarien von Koroutinen skizzieren. Danach konnte ich noch etwas über Fibers bzw. User-Threads erzählen, die große Ähnlichkeiten zu Koroutinen haben. Fazit neben dem Vorteil der einfachen Umsetzung für viele Probleme: "Scale starts with 1" und "it's all about performance".

Die vielen Diskussionen während und noch lange nach dem Vortrag zeigten, wie interessant das Thema für alle war, und wieviel Wissenslücken vorhanden waren. Alle - auch ich - konnten von diesem Abend neue Ideen und Anregungen mit nach Hause nehmen - und für mich zeigte sich mal wieder, dass Vorträge die bei "Null" starten oft mehr bringen als abgedrehten Präsentationen.

C++ User-Treffen in Düsseldorf am 17.02.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf führte Odin Holmes die 18 Anwesenden in die Meta-Programmierung in C++ ein. Zuerst stellte er vor, welche Features in C++ für die Meta-Programmierung vorhanden sind: C-Makros, "constexpr" und Templates. Während C-Makros nur dann sinnvoll sind, wenn man Bugs in seine Programme einbringen möchte und unleserlichen Code erzeugen möchte - sind "constexpr" und Templates die typischen modernen Mittel für Meta-Programmierung in C++. "constexpr" wird heutzutage eingesetzt um zur Compile-Zeit Werte zu berechnen - Templates um zur Compile-Zeit mit Typen zu arbeiten. Klar, dass sich Odin im weiteren Verlauf des Abends auf "constexpr" und Templates beschränkte.

Odin stellte nun die grundlegenden Bausteine und Techniken von C++ Meta-Programmierung vor, und verglich sie immer mit den normalen imperativen Sprach-Konstruktoren: If- und Switch-Anweisungen, Rekursion für Schleifen, usw. Hierbei wurde allen Anwesenden klar, dass C++ Meta-Programmierung mehr einer funktionalen als einer imperativen Programmierweise entspricht. Werte und Typen sind in der C++ Meta-Programmierung immer konstant, und statt Schleifen muss jede Art von Iteration mit Rekursion erledigt werden. Der ein oder andere fühlte sich auch stark an Haskell erinnert - zumindest wenn man die vielen "template" und "typename" Schlüsselwörter aus den Beispielen entfernt hätte.

Nach den grundlegenden Bausteinen wurde es etwas komplizierter: Odin zeigte einen Sortier-Algorithmus, basierend auf den vorgestellten Bausteinen. Nebenher führte er noch Template-Template-Paramter, stellte die Vorteile von Using-Aliases vor und ging auf "sizeof..." bei Parameter-Packs ein.

Am Schluß erzählte er dann noch von seiner praktischen Anwendung von C++ Meta-Programmierung in seiner täglichen Arbeit. Sein Arbeitsgebiet erfordert die effiziente Low-Level Programmierung, u.a. das direkte Ansprechen von Hardware und Registern. Hierbei sind viele Abhängigkeiten und Regeln zu beachten - bis hin dass der Compiler viele scheinbar überflüssigen Zuweisungen nicht weg-optimieren darf. Um hier das Schreiben zu erleichtern, hat er sich eine DSEL geschrieben, die dieses gesamte Zeug übernimmt und behandelt - und dabei einfach zu nutzen ist. Sein erreichtes Ziel war hierbei: Code schreiben zu können der effizienter als der normale handgeschriebene C Code ist - und dabei "ganz einfach" zu schreiben ist.

In der folgenden sehr langen Diskussion wechselte die Abstraktion ständig: auf der einen Seite wurde über "constexpr", Meta-Programmierung und Templates geredet (was sicher kein Low-Level Zeugs ist) - auf der anderen Seite über Probleme beim Ansprechen von Hardware-Registern auf verschiedenen Architekturen gefachsimpelt (was ziemlich Low-Level ist). Aber vielleicht gerade deshalb war es für viele ein sehr interessanter und aufschlussreicher Abend - mit Programmier-Aspekten, die man sonst nicht jeden Tag diskutiert.

Die meisten Arbeiten von Odin stehen in der Open-Source Bibliothek Kvasir zur allgemeinen Verfügung. Wer also weiteres Interesse hat, sollte sich diese Lib vielleicht mal näher anschauen.

C++ User-Treffen in Düsseldorf am 20.01.2016

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf drehte sich alles um das berühmteste Apfelmännchen der Welt und seine Formel "z=z^2+c". Sven Johannsen führte uns anhand seiner persönlichen Geschichte durch rund 30 Jahre Apfelmännchen, und versuchte uns dabei vor allem seine Performance- und Multithreaded-Untersuchungen in C++ vorzustellen. 15 Apfelmännchen Interessierte waren gekommen, um sich auf die Reise durch die complexe Welt von "z=z^2+c" einzulassen.

Zuerst stellte Sven auf seiner Apfelmännchen Reise seine persönliche Motivation in den Vordergrund: wie hatte er das Apfelmännchen kennengelernt, was ist es überhaupt, und warum hatte es ihn auf über 30 Jahren soviel begleitet? Für Sven ist jede neue Programmiersprache zuerst immer auch eine Begegnung mit dem Apfelmännchen, da er als erstes immer das Apfelmännchen in ASCII-Art umsetzt. Von daher haben er und das Apfelmännchen eine lange gemeinsame Geschichte, die man dem gesamten Abend über spürte.

Am aktuellen Zwischen-Ende der Reise kamen Sven und das Apfelmännchen dann natürlich auch bei C++ an. Sven stellte viele Implementierungen und Untersuchungen vor. Er verglich Implementierungen mit Float, Double, Complex<Float>, Complex<Double>, Int und Long. Er variierte die Fließkomma-Compiler-Einstellungen beim GCC. Er veränderte die Struktur der Schleifen bis hin zur Nutzung der Standard-Algorithmen. Er parallelisierte die Schleifen mit OpenMP, TBB und C++14 Futures. Und stellte jedesmal die Ergebnisse zur Diskussion und erklärte sie anhand seiner eigenen Untersuchungen. So lernten wir alle viel über Optimierungen, Performance-Stellschrauben und Parallelisierungen.

Sven hatte seinem Vortrags-Titel "Alles außer SIMD" angehängt - und am Ende erzählte er warum: die mit Abstand beste Optimierung brachte die Nutzung von eben SIMD. Nur leider ist SIMD immer noch nicht Teil des C++ Standards, und leider auch immer noch nicht als Bibliothek in Boost vorhanden - und so musste er selber Hand anlegen. Und das hätte den Zeitrahmen des Abends dann wirklich gesprengt - so stellte er nur die Resultate vor.

Am Ende läßt sich sagen, dass wir nun wahrscheinlich alle viel bewußter Äpfel essen werden ;-) oder auch nicht. Aber es war ein kurzweiliger interessanter Abend mit vielen Performance-Aspekten, Diskussionen und Einsichten. Danke nochmal von hier an Sven für den Vortrag.

C++ User-Treffen in Düsseldorf am 16.12.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf feierten wir Geburtstag. Vor 4 Jahren - am 14.12.2011 fand das erste C++ User-Treffen in Düsseldorf statt - und so konnten wir diesmal das 4-jährige Bestehen feiern. Und wie bei jedem Dezember-Treffen der letzten Jahre haben wir es auch diesmal mit einem C++ Quiz und Keksen & Kuchen begangen. 13 Teilnehmer waren gekommen und verbrachten einen interessanten und lustigen Abend mit Fragen, Keksen und Kuchen. Da wir diesmal einen französischen Gast hatten, der seit kurzem in Düsseldorf arbeitete und noch kein Deutsch konnte, schwenkten wir spontan auf Englisch um.

Zuerst begrüßte Jens Weller alle Anwesenden und blickte kurz auf die letzten 4 Jahre C++ User-Treffen Düsseldorf zurück. Außerdem informierte er uns über den Stand der Videos von der Meeting C++ von Anfang Dezember in Berlin.

Dann übernahm ich die Bühne. Ich hatte diesmal nur 36 Fragen vorbereitet - da einige Fragen aber etwas aufwändiger waren - hoffte ich dass die Fragen für die verfügbare Zeit reichen würden. Und das klappte auch erstaunlich gut - kurz nach 22:00 waren wir durch. Doch zurück zum Anfang. Wie immer waren meine Fragen bunt gemischt. Einige waren einfach und konnten von allen Anwesenden in wenigen Sekunden gelöst werden. Andere beleuchteten Details von C++, die kaum einer kannte und in der Praxis wohl nur selten vorkommen - wenn überhaupt. Hier wurde oft nur gerätselt und geraten - und die Antworten lagen daher auch häufig daneben. Andere Fragen beleuchteten unbekannte Aspekte eigentlich bekannter Themen - z.B. hatte ich 8 kleine Programme vorbereitet, die Shared- und Weak-Pointer nutzten. Eigentlich ein wohlbekanntes Thema, und wohl fast jeder nutzt sie täglich. Aber auch hier gab es unbekannte Bereiche - was sich darin zeigte, dass das exakte Verhalten nicht aller Programme vorher exakt beschrieben werden konnte.

Außerdem hatte ich natürlich auch einige eher lustige Fragen vorbereitet, u.a. hatte ich mich - wie schon letztes Jahr - beim "The International Obfuscated C Code Contest" (IOCCC) bedient. Außerdem stellt ich ein Quine Programm vor, und als kaum zu topende Herausforderung dann noch eine Quine-Variante, die eine unendliche Schleife über 100 verschiedene Programmiersprachen darstellte. Wen das näher interessiert - man findet das "100 Language Uroboros Quine" hier.

Am Ende des Abends waren alle wohlgesättigt an Körper & Geist. Viele Fragen hatten für Erheiterung und natürlich Diskussionen gesorgt, und uns so einen kurzweiligen Abend beschert. Danke auch nochmal an alle Spender von Keksen & Kuchen, die damit zusätzlich für einen leckeren Abend gesorgt hatten - selbst wenn ich als Vortragender das nur sehr wenig nutzen konnte.

C++ User-Treffen in Düsseldorf am 18.11.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf gab es keinen einzelnen großen Vortrag, sondern mehrere Kleine. Geplant waren eigentlich 7 Vorträge, aber nach nur 3 Vorträgen war es schon nach 22:00 Uhr und der Abend am Ende angekommen. 7 C++ Interessierte waren gekommen, um dem bunten Strauß an Themen zu lauschen.

Den Einstieg übernahm Jens Weller mit einem Erfahrungsbericht - er hatte den HTML-Editor "TinyMCE" in sein eigenes in C++ mit Qt geschriebenes CMS-System eingebettet. Da TinyMCE in JavaScript geschrieben ist und eigentlich im Browser läuft, war dies kein leichtes Unterfangen. Jens zeigte die Probleme auf, die ihm die Einbettung beschert hatte, und wie er sie gelöst hatte. Neben einigem C++ Code sahen wir auch JavaScript Code, da dies für die Anbindung natürlich notwendig war. War ein netter kleiner Vortrag, über die Probleme und Fallen des täglichen Programmierens bei einer nicht normalen Aufgabe. Sicher etwas, was man selber nur selten braucht, aber trotzdem ein interessanter Vortrag aus der Praxis. Dies zeigte sich auch in den vielen Fragen und Anmerkungen der Anwesenden.

Jens hatte noch einen zweiten Vortrag vorbereitet - und da sein Rechner schon mal lief und angeschlossen war machte er direkt weiter. Diesmal ging es um die Nutzung von "Boost.Serialisation". Die normale Nutzung von Boost.Serialisation setzt voraus, dass man entweder seine Attribute "public" macht, oder die Template-Serialisierungs-Funktionen in die Klassen einfügt. als Templates im Header direkt implementiert. Jens erläuterte, warum ihm beide Wege bei seinem Problem nicht gefallen hatten - Und so hatte er sich auf die Suche nach einem dritten Lösungs-Weg gemacht - und fand ihn mit "Boost.Präprozessor", "std::tuple" und "std::tie". Später war, nach einem Hinweis aus dem Internet es doch mit "friend" zu versuchen - noch eine vierte Lösung hinzugekommen. Die meisten Informationen dieses Vortrags findet man auch bei Meeting C++ in einem Blog-Eintrag von Jens.

Nach diesen beiden Vorträgen war schon rund eine Stunde rum, und es deutete sich damit an, dass 7 Vorträge so nicht zu schaffen sind. Nach Jens übernahm nun Max Neunhöffer den Stab und erfreute uns mit einem Vortrag über VelocyPack. VelocyPack ist ein JSON ähnliches binäres Format, das auf hohe Performance und geringe Größe hin optimiert wurde - für die NoSQL Datenbank ArangoDB wurde ein solches Format benötigt. Als erstes motivierte Max die Einführung eines weiteres Serialisierungs-Formats - sie hatten sich viele fertige Lösungen angeschaut - aber keine gefunden, die ihre Anforderungen abdeckte. Darum hatten sie ein neues Format entwickelt - eben "VelocyPack". Den restlichen Vortrag zeigte Max den Aufbau von VelocyPack, die Grenzen und Möglichkeiten, und anhand vieler Beispiele die Nutzung der VelocyPack-Bibliothek. Eine Menge Fragen und viele Diskussionen, gerade auch zum Thema Performance und Anwendungsgebiete, zeigten das große Interesse an einer solch performanten und kompakten Lösung.

Auf Grund der Fragen und Diskussionen endete der dritte Vortrag erst nach 22:00. Damit stand fest - die restlichen Vorträge müssen warten, aber sie laufen ja nicht weg. Der Abend war dann aber noch nicht zuende - es wurde noch viel diskutiert. Primär natürlich über die Vorträge und C++, aber es gab auch eine Menge anderer Themen. Wie eigentlich immer war es ein Abend, der sich für alle gelohnt hat.

C++ User-Treffen in Düsseldorf am 21.10.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf drehte sich für 12 C++ Interessierte fast alles um Multi-Methoden ( Multi-Methoden in der deutschen Wikipedia / multi dispatch in der englischen Wikipedia ). Den Start übernahm aber Jens Weller mit einem anderen Thema: er berichtet kurz von seinen Konferenz-Besuchen auf der cppcon 2015 und dem Qt World Summit 2015.

Danach ging es dann aber zur Sache. Ich hatte einen kleinen Vortrag vorbereitet, der erstmal theoretisch Multi-Methoden einführte und Beispiele in Pseudo-C++ (angelehnt an an die C++ Bibliothek Loki) und der Programmiersprache Dylan ( Dylan in der deutschen Wikipedia / Dylan in der englischen Wikipedia ) enthielt. Vor allem versuchte ich zu zeigen, dass Multi-Methoden den Programmcode stark vereinfachen, und OO Komponenten mit echter Wiederverwendung und Erweiterbarkeit (das verspricht uns OO doch seit 25 Jahren) nur mit Multi-Methoden sinnvoll möglich sind. Natürlich konnten auch auch alle gezeigten Probleme mit Single-Dispatch gelöst werden, aber selbst bei meinen einfachen Beispielen waren die Single-Dispatch Lösungen schon extrem lang, aufwändig, wartungs-intensiv, und kaum noch zu verstehen. Und sie funktionierten nur, wenn man schon im Vorfeld an vielen Stellen die Erweiterbarkeit vorbereitet hatte. Wie viel einfacher und kürzer und wartungsfreundlicher waren dagegen die Lösungen mit Multi-Methoden.

Hinweis - in meiner Argumentation bin ich stark dem Artikel über Multi-Methoden von Ruben Saar aus dem Journal of Object-Oriented Programming (JOOP) vom März/April 2000 gefolgt.

Leider enthält C++ keine Multi-Methoden in der Sprache. Auf der anderen Seite ist C++ so mächtig, dass sich Multi-Methoden mit Bibliotheken akzeptabel nachbilden lassen. Ein Beispiel hierfür ist die schon erwähnte C++ Bibliothek Loki. Einen anderen Ansatz beschreibt Scott Meyers in seinem Buch "Mehr Effektiv C++ programmieren". Weitere Bibliotheken finden sich im Internet, unter ihnen auch die C++ Bibliothek "multidispatch-lib" von Michael Becker.

Damit übernahm Michael das Vortrags-Token und stellte seine C++ Bibliothek "multidispatch-lib" im Detail vor. Sie basiert im Kern stark auf Template-Meta-Programmierung und vielen C++14 Sprachmitteln - das aktuelle Microsoft Visual Studio 2015 übersetzt sie also bislang nicht. Zur Nutzung muss man seine Klassen-Hierarchien leider um zusätzliche Funktionen ergänzen, und "multidispatch-lib" deckt verschiedene Anforderungen wie z.B. "next-dispatch" und "Teil-Matches" nicht ab. Wenn man - wie ich - bei Multi-Methoden aus der OO-Ecke kommt (z.B. von Dylan) dann vermisst man diese Features sehr. Auf der anderen Seite kann "multidispatch-lib" z.B. auch mit Boost.Variant- und Std.Variant-Typen umgehen und mit ihnen auch einen Multi-Dispatch ohne Klassen-Hierarchien abbilden. Damit deckt sie einige sehr interessante und hilfreiche Anwendungsfälle ab, die dem aktuellen C++ Gedanken mit weniger Ableitung sicher sehr entgegen kommen.

C++ User-Treffen in Düsseldorf am 16.09.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf war das Thema die Multi-Prozessor-Programmierung in C++ mit der "Intel Threading-Building-Block Library" - kurz "TBB". Ich hatte einen Vortrag quer durch die TBB für die nächsten 2 Stunden vorbereitet. Obwohl dies ein extrem spannendes und heutzutage sehr wichtiges Thema ist, waren nur 7 C++ Programmierer gekommen. Wir haben uns davon aber nicht abhalten lassen, und einen interessanten Abend erlebt.

Zuerst habe ich versucht zu motivieren, warum die Multi-Prozessor-Programmierung heutzutage so wichtig ist: seit rund 10 Jahren steigen die Taktfrequenzen der Prozessoren nur noch sehr langsam an - statt dessen steigt die Anzahl an Cores und Prozessoren in den Rechnern stetig. Damit ist Multi-Prozessor-Programmierung - besser Multi-Core-Programmierung - zwingend notwendig um die Prozessoren auszulasten. Die Frage ist nur, wie macht man dies. Viele Programmierer versuchen diesem Problem mit Threads, Mutexen, Atomics usw. zu begegnen - ich halte dies aber für die falsche Vorgehensweise. Diese Elemente sind sehr basic - und sollten auf Basic-Anwendungs-Fälle beschränkt bleiben. Im Normalfall sollte man sich viel weiter oben in "Doug's Pyramide" bewegen - eine Möglichkeit hierfür ist eben die TBB. Sie abstrahiert von den Threads und bildet die Arbeit auf Tasks ab, die dann auf einer höheren Abstraktions-Ebene genutzt werden können.

Für den Einstieg in die TBB hatte ich den parallelen Algorithmus "parallel_for" gewählt. Zum einen zeigt er sehr schön, wie einfach die Nutzung der parallelen Algorithmen in der TBB ist - zum anderen war er ein guter Aufhänger für viele weitere Themen: Range-Objekte und Partitioner, Tasks, Task-Gruppen und Task-Gruppen-Kontexte zum Canceln, Exception-Handling, Thread-Pool, Worker-Threads, Work-Stealing und auch dynamisches Task-Scheduling. Und es ging Schlag auf Schlag weiter: Fork & Join mit Task-Gruppen oder "parallel_invoke", Task-baiserte Ansätze mit selbst erzeugten Tasks, und zum Schluß noch Flow-Graphs.

Am Ende stellte ich noch kurz den Intel Flow-Graph-Designer in einer Alpha Version vor, mit dem man grafisch Flow-Graphs erstellen kann und der dann darauf basierend C++ Code erzeugt. Außerdem ist er in der Lage Trace-Daten von Flow-Graphen einzulesen, "step-for-step" abzuspielen und dadurch die Fehler-Analyse und Optimierung stark zu unterstützen.

Nach über 2 Stunden und 147 Folien waren wir am Ende der TBB-Reise angekommen. Am Anfang hatten mich mehrere Anwesende gefragt: Warum die TBB? Warum soll ich mich mit einer solchen Bibliothek beschäftigen? Diese Frage hatte sich implizit beantwortet - und die Resonanz war auch entsprechend. Die TBB bietet soviele Hilfen und Abstraktion für die Multi-Prozessor-Programmierung, dass man sich eher fragen muss: Warum nicht?

Natürlich gibt es auch Alternativen: OpenMP, Cilk++, CAF, PPL, Parallel-STL, HPX, React, u.v.m. - und wir haben diese im Anschluß auch noch diskutiert und verglichen. Wichtiger ist aber: dass man eben nicht auf der Ebene von Threads und Atomics programmiert, sondern höhere Abstraktionen bevorzugt - und die TBB ist hier eine mögliche Option.

C++ User-Treffen in Düsseldorf am 19.08.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf ging es um ein ziemlich untypisches Thema von C++ - die Web-Server-Programmierung. Hier sind vorzugsweise eher Sprachen wie PHP, Python, Ruby oder auch Java vertreten, weniger C++. Umso interessanter mal zu hören, was C++ in diesem Umfeld zu bieten hat - und so waren 14 Interessierte ins Chaosdorf gekommen. Ismail Khoffi stellte das C++ Web-Framework "CppCMS" vor und zeigte die Umsetzung einer Todo-Listen Applikation mit "CppCMS". Seinen Vortrag findet man im Internet unter http://www.slides.com/ismailkhoffi/cppcms-intro.

Zuerst stellte Ismail kurz den Hintergrund von "CppCMS" vor und wies nochmal explizit darauf hin, dass "CppCMS" trotz des Namens kein Content-Management-System wie z.B. WordPress ist, sondern ein C++ Framework zur Entwicklung server-seitiger Web-Applikationen. Bevor er dann zu den Details und realem Code wechselte, ging er noch auf die Vor- und Nachteile von C++ im Verhältnis zu z.B. PHP oder Rapid-Prototyping Web-Frameworks wie Ruby-on-Rails ein. Neben Security sind die Haupt-Vorteile von C++ erwartungsgemäß die Performance - und damit einhergehend die Kosten. Schnellere Applikationen benötigen weniger Server und vor allem auch weniger Strom. So berichtete er, dass z.B. Facebook seit dem erfolgten Umstieg von PHP auf C++ auf Server-Seite allein Strom-Kosten in drei-stelliger Millionen-Höhe im Jahr spart.

Danach stellte Ismail "CppCMS" detaillierter vor, und wechselte dann auch in den Code seiner mitgebrachten kleinen "Todo-Listen" Web-Applikation. Der Aufbau der Applikation ähnelte grundsätzlich z.B. einer Rails-Applikation - auch in "CppCMS" findet sich als Basis das MVC-Pattern wieder, und natürlich gibt es Lösungen für Session-Handlung, Routing und vieles mehr. Für mehr Diskussions-Stoff sorgte dann erstaunlicherweise ein ganz anderer Aspekt seiner Applikation - die Anbindung an die PostgreSQL Datenbank. Hier hatte Ismail der Einfachheit halber die SQL Connectivity Library "CppDB" gewählt, die stark auf Strings aufsetzt und damit wenig Typ-Sicherheit bietet. Diese Entscheidung wurde stark diskutiert und "CppDB" und mit den Alternativen wie z.B. "sqlpp11" verglichen. Und natürlich führte die Diskussion auch immer wieder zu dem Vergleich von "CppDB" mit anderen C++ Web-Frameworks wie z.B. "Wt".

Unterm Strich war der Abend wiedermal sehr interessant, kurzweilig und spannend. Man konnte gut sehen, dass Web-Entwicklung auch in C++ ganz problemlos möglich ist und einige Vorteile bietet. Größter Nachteil sind sicher die relativ langen "Turn-Around" Zeiten, was die Entwicklung bei häufigen Änderungen stark verlangsamt - hier sind Rapid-Prototyping Web-Frameworks wie Ruby-on-Rails klar im Vorteil.

C++ User-Treffen in Düsseldorf am 15.07.2015

Am diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf konnte ich leider nicht teilnehmen. Jens Weller hat über die C++Now und die NDC berichtet, an denen er teilgenommen hat.

C++ User-Treffen in Düsseldorf am 17.06.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren 13 interessierte C++ Programmierer anwesend. Frank Birbacher hatte den Abend übernommen und sich meine Kochshow vom letzten Monat zu Herzen genommen und sich auch auf Basis von Cinder an eigene Asteroids-Versuche herangewagt. Meine C++ Kochshow hatte den Focus auf Einfachheit und die Motivation "sich an sowas ran zu trauen" gelegt, und daher OpenGLnur minimal genutzt. Ganz im Gegenteil war ich bewußt viele Vereinfachungen eingegangen, die in einem "echten" Spiel nicht vorkommen sollten. So hatte ich z.B. auf frame-basierte Bewegungen gesetzt, statt sie zeit-basiert anzugehen. Ich hatte direkt mit Pixel-Koordinaten gerechnet, statt komplexere mathematische Transformationen einzusetzen. Oder ich hatte z.B. einfache farbige Shades für meine Figuren genutzt, statt komplexe "schöne" Gebilde OpenGL-like aus Dreiecken mit Texturen zu komponieren. Mir ging es um Einfachheit, und dass auch ein Einsteiger alle meine Schritte problemlos direkt nachvollziehen konnte.

Frank nahm sich nun dieser komplexeren Themen an und erklärte direkt als erstes die Transformations-Matrizen aus OpenGL. Damit konnte er Figuren erstellen, die auf dem virtuellen Koordinaten-System "-1 .. +1" basierten, sich aber dynamisch an die echte Fenstergröße anpaßten. Seine Beispiele begannen mit einem einfachen Stern, der den ganzen Bildschirm einnahm und führten dann zu einem vollständigen Sternen-Hintergrund.

Mit der Vorstellung von zeit-basierten Berechnungen brachte er seine Sterne zum Leuchten und Funkeln. Jeder Stern pulsierte dabei in seinem eigenen zeit-abhängigen Rhythmus. Frame-Stotterer konnten seine Sterne nicht aus der Ruhe bringen. Und dann nutzte er noch die Rotations-Matrix von OpenGL und ließ den funkelnden Sternen-Hintergrund langsam rotieren - natürlich wieder zeit-basiert. Viele "Oh"s und "Ah"s aus dem Publikum begleiteten dieses romantische Bild.

Zu guter Letzt erstellte Frank noch komplexe Asteroiden-Gebilde aus vielen Dreiecken - dagegen waren meine einfachen runden Asteroiden vom letzten Monat wirklich nur häßlich. Und dann krönte er seine Asteroiden noch mit Texturen, und nutzte die Gelegenheit Textur-Koordinaten vorzustellen - ohne die die Dreiecke keine einheitliche Oberfläche bekommen hätten.

Es war ein sehr interessanter Abend mit etwas Mathematik und vielen schönen Bildern. Frank zeigte sehr eindrucksvoll, dass OpenGL weitaus mehr kann als ich letzten Monat genutzt hatte - und das damit komplexere Szenarien möglich sind. Aber es zeigte sich auch, dass die Umsetzung zwar nicht wirklich schwierig ist (u.a. dank Cinder) - aber schon einiges mehr an Arbeit und Gehirnschmalz erfordert. Auf jeden Fall war der Abend eine wunderschöne Ergänzung zu meiner C++ Kochshow vom letzten Monat - danke Frank.

C++ User-Treffen in Düsseldorf am 20.05.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren leider nur 6 Teilnehmer erschienen. Ich hatte für diesen Abend eine kleine "C++ Kochshow" vorbereitet: ich wollte mit den Anwesenden "live" ein kleines Spiel entwickeln. Im Sinne einer normalen "Kochshow" sollte es eine reine Präsentation werden (d.h. die Teilnehmer hatten quasi keine Einfluß-Möglichkeiten), und damit alles in der "Zeit" fertig wird, hatte ich - wie bei den großen Vorbildern im Fernsehen - alle Code-Teile schon "vorgekocht" bzw. fertig im "Backofen" liegen.

Das angedachte Programm war ein kleines "Asteroids" Spiel, wie es wohl jeder kennt. Und als erstes stellte ich vor, was unser gemeinsames Ziel des Abends war - indem ich eine Runde "Asteroids" spielte. Danach war jedem klar: ISO C++ reicht hierfür nicht aus, denn ISO C++ enthält keinerlei grafische Elemente - egal ob Spiele- oder Oberflächen-Elemente. Also hatte ich wohl auf mehr zurückgreifen müssen - und hier hatte ich mich für die Bibliothek Cinder entschieden. Ich hatte Cinder vor 1 1/2 Jahren durch Zufall kennengelernt, und war stark beeindruckt von der Einfachheit gewesen, mit der sich hiermit Spiele oder andere Anwendungen in C++ schreiben lassen - mein erstes kleines Spiel stand damals nach ca. 6 Stunden.

Ich bin kein Cinder-Experte, ganz im Gegenteil - und auch Spiele programmiere ich sonst eher nicht. Auch OpenGL, DircetX oder andere grafische oder spiel-spezifische Themen sind sonst nicht mein Bereich - von daher war ich überhaupt nicht prädestiniert für diese "Kochshow". Aber mir ging es ja auch nicht um solche Themen, sondern ich wollte einfach zeigen dass man in 2 Stunden in C++ ein eches vollständiges kleines Spiel programmieren kann - und den Teilnehmern Lust auf mehr machen.

Ich hatte das Asteroids Programm in 24 kleine Schritte zerlegt - d.h. 24 Projekte aufgesetzt, die Schritt für Schritt das Asteroids entstehen lassen würden. Das erste Projekt zeigte z.B. nur, wie man ein Cinder-Projekt aufsetzt und aus welchen Bestandteilen es besteht. Das zweite Projekt zeigte weitere Konfigurations-Möglichkeiten eines Cinder-Programms, und im dritten Projekt wurden nur ein paar einfarbige Kreise auf schwarzem Hintergrund gezeichnet. Aber dann wurde es interessanter: in den folgenden Projekten wurde ein Raumschiff gezeichnet, das Raumschiff zum Drehen gebracht, dann beschleunigt und abgebremst, die Spielfläche normalisiert, und die Zeichen-Behandlung an den Kanten verbessert. Danach konnte man mit dem Raumschiff schon mal die Spielewelt in Ruhe "erkunden". Als nächstes wurden Raketen integriert, das Spiel etwas "refactored", Explosionen erzeugt und dann auch noch Asteroiden verschiedener Größe hinzugefügt - und zwischendurch immer mal wieder "refactored". Dann ging es an die Kollisions- und Treffer-Behandlung - und Punkte und ein Vorrat an Leben (Schiffen) wurde integriert. Damit war das Spiel nach etwas über 2 Stunden und 24 Schritten fertig.

Zwischendurch und am Schluß kamen natürlich viele Fragen auf, was Cinder jeweils kann, warum ich dieses und jenes so und nicht anders gelöst hätte, und wie man Dinge anders machen könnte. Und selbst wenn nicht jeder Teilnehmer jede Zeile so wie ich geschrieben hätte, so waren doch hinterher alle begeistert, wie schön einfach und schnell man in C++ mit Cinder ein komplettes kleines Spiel schreiben kann.

C++ User-Treffen in Düsseldorf am 15.04.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf ging es um das Thema "Encryption in C++" und 10 Interessierte waren gekommen und den Abend diesem wichtigen Thema zu widmen - Jens Weller hatte einen entsprechenden Vortrag vorbereitet.

Zuerst führte Jens kurz in das Thema ein, und warum er sich näher damit beschäftigt hatte - dann stellte er 3 Libs vor, die er im Laufe des Vortrags näher beleuchten wollte. Mit jeder Lib setzte er ein Verschlüsselungs-Verfahren wie z.B. AES um, und zeigte dabei welche Optionen, aber auch welche möglichen Fehl-Benutzungen die Bibliotheken bieten - und da Fehl-Benutzungen oft zu Sicherheitslücken führen, war dies ein besonders wichtiges Thema.

Wie so oft lebte der Abend aber nicht nur vom Vortrag, sondern auch von der Beteiligung aller Anwesenden - schon während des Vortrags und noch vielmehr hinterher, entwickelte sich manche Diskussion und gab es manche Frage - manche Anwesende hatten schon viel Erfahrung mit Verschlüsselung, andere weniger. Am Ende hatte wohl jeder ein paar neue Dinge gelernt und konnte etwas Neues mit nach Hause nehmen.

C++ User-Treffen in Düsseldorf am 18.03.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren 14 C++ Programmierer gekommen, und ein interessanter Abend mit Pizzen erwartete sie. Zu Besuch war diesmal die englische Firma "Undo-Software", um ihren "record-and-replay reversible" Debugger "UndoDB" vorzustellen. Zusätzlich hatte "Undo-Software" für diesen Abend Pizzen gesponsort - und Jens Weller hatte im Vorfeld für alle angemeldeten Teilnehmer Pizzen geordert. Für das leibliche Wohl war also gesorgt, und wir konnten uns entspannt dem Vortrag widmen.

Julian Smith von "Undo-Software" hatte einige Folien für den Vortrag mitgebracht, verbrachte aber die meiste Zeit im Debugger selber und zeigte zuerst, wie man mit "UndoDB" arbeitet und wie leicht man typische Programmier-Fehler mit "UndoDB" finden kann. Egal, ob Assertions, Race-Condition, Memory-Leaks, oder einfach nur unerwartete Werte - in allen Fällen war es ein leichtes mit "UndoDB" in der Zeit "rückwärts" zu gehen und so schnell und sicher die Fehler-Ursache aufzuspüren.

Gegen Ende der Präsentation erklärte Julian Smith dann auch, wie "UndoDB" intern arbeitet, ohne dass dabei zuviel Speicher benötigt wird und die Performance zu sehr einbricht. Dazu schneiden sie nur die Daten an den Stellen mit, an denen nicht reproduzierbare Ereignisse auftauchen, z.B. das Lesen von Daten von Sockets. Um diese Stellen zu finden, analysieren sie den Maschinencode und kennen die Auswirkungen aller System-Calls. Alle anderen Zustände lassen sich dann jederzeit wieder herstellen, da ein Computer nun mal ein deterministisches Wesen hat - selbst wenn es uns oft nicht so vorkommt.

Die Präsentation ging "nur" über rund eine Stunde, d.h. war hinterher noch viel Platz für Fragen - und der wurde reichlich genutzt. Ob es um die genauere interne Arbeitsweise des Debuggers ging, weitere Beispiele für konkrete Fehlerfälle, oder allgemeine Fragen nach den unterstützten Plattformen, Lizenzen oder einfach dem Alter und der Größe von "Undo-Software" - Julian Smith beantwortete alle Fragen mit viel Geduld und Engagement. Und es gab wirklich viele Fragen.

C++ User-Treffen in Düsseldorf am 18.02.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren wieder 12 C++ Programmierer gekommen, um zu fachsimpeln und Neues über C++ zu erfahren.

Jens Weller hatte im Vorfeld die Library-Proposals für den kommenden Standard C++17 durchgearbeitet, da diese auf dem Library-Working-Group Treffen in Köln nächste Woche das Thema sein würden, und stellte sie vor. Manche Proposals wurden nur kurz vorgestellt und lösten auch keine weiteren Diskussionen aus, da sie trivial und/oder klar waren - z.B. "n4255" für Allokatoren für Regular-Expressions, "n4280" für Non-Member Funktionen wie "size" und Andere, oder "n4371" für den minimal incomplete type support für alle Standard-Container. Andere Proposals wiederum wurden ausführlicher vorgestellt bzw. lösten zum Teil intensive Diskussionen aus.

"n4370" über Networking basierend auf den Ideen von Boost.Asio war z.B. eins der Proposals, die Jens weitaus detaillierter vorstellte. Sicher auch, da es im Gegensatz zu vielen anderen Proposals nicht klein ist und Networking ein Thema ist dass für die Programmierung wichtig ist und bislang eine schmerzliche Lücke im C++ Standard darstellt.

Größere Diskussionen löste dagegen z.B. "n4273" über Uniform Conatiner Erasure aus. Zum einen, da es sofort großen Anklang unter den Anwesenden fand, zum anderen aber auch da es sich auf "remove" und "remove_if" konzentriert und dabei scheinbar z.B. "unique" außer Acht läßt. Auch z.B. "n4282" über einen neuen Smart-Pointer, der einfach nur einen Raw-Zeiger kapselt, um die Intention von Code klarer zu machen blieb nicht ohne Wider- und Zuspruch. Und "n4314" über daten-unabhängige Funktionen für das wichtige Thema Verschlüsselung und Sicherheit sorgte verständlicherweise für rege Beteiligung.

Ganz allgemein war die intensivste Diskussion aber ganz unabhängig von jedem einzelnen Proposal die Frage, wohin sich C++ entwickelt, was "Modern C++" wirklich ist und auszeichnet, ob Objekt-Orientierung bald Legacy-Design ist, wie stark generische Lambdas C++ in Zukunft prägen werden, ob Type-Erasures sich in der Breite durchsetzen werden und was man damit umsetzen kann, und vieles mehr.

Alles in allem ein spannender Abend, der stark von den Diskussionen und Meinungen der Teilnehmer lebte - uns aber auch klar machte wohin sich C++ in den nächsten Jahren - zumindest in der Bibliothek - entwickeln wird. Für alle die, die nicht anwesend sein konnten - Jens hat eine Übersicht der Library-Propsals auf seinem Meeting C++ Blog veröffentlicht:

C++ User-Treffen in Düsseldorf am 21.01.2015

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren 12 C++ Programmierer anwesend und freuten sich auf einen schönen und interessanten Abend. Und der began diesmal mit knapp einer Stunde C++ Quiz. Im Dezember waren wir ja leider mit den 50 Fragen nicht fertig geworden, und so konnten sich die Anwesenden heute noch zuerst den restlichen Herausforderungen stellen. Und das Jahr began, wie das letzte aufgehört hatte - viele Fragen führten zu spannenden Diskussionen und trotzdem falschen Antworten...

Da von Anfang an klar war, dass die restlichen Fragen des C++ Quiz den Abend nicht vollständig füllen würden, hatte ich vorgesorgt. Ich hatte einen älteren Vortrag über "Boost.Any" über Weihnachten aktualisiert - und von Sven Johannsen in den letzten Wochen auch noch zusätzlichen Input bekommen - und ihn mitgebracht. Für die zweite Stunde stand also nun ein Vortrag über "Boost.Any" an.

"Boost.Any" ist sicher nicht das spannenste Thema, aber auf der anderen Seite eine kleine nette und in vielen Situationen sehr hilfreiche Bibliothek. Und häufig ist es für die tägliche Prduktivität viel wichtiger, all diese kleinen hilfreichen Bibliotheken zu kennen und zu nutzen, als die nächste abgedrehte Technik zu beherrschen für die man selber oft kaum Anwendungsfälle hat. Und so stellte ich "Boost.Any" in Ruhe vor - von der einfachen Nutzung, bis hin zu komplexeren Anwendungsfällen. Sven Johannsen, der auch schon viel mit "Boost.Any" gearbeitet hat, hatte meine Präsentation im Vorfeld um einige Folien erweitert. Er übernahm immer wieder temporär die Präsentation und berichtete von seinen Erfahrungen. Wie hilfreich "Boost.Any" ist, kann man vielleicht auch daran ablesen, dass "Any" mittlerweile Teil der Technical Specification "Extensions for Library Fundamentals" (n4335) ist, und daher im nächsten C++ Standard enthalten sein wird.

Am Ende des Treffens wurde noch etwas über "tägliche" C++ Probleme diskutiert. So warf ich z.B. die Frage auf, wie man allgemein die Basis-Klassen von Template-Parametern betimmen kann, um sie dann als Rückgabe-Typ nutzen zu können. Auch die mögichen Implementierungen von Boost.Any wurden diskutiert, die "Extensions for Library Fundamentals" waren Thema, und die alternativen Möglichenkeiten von "Boost.Type-Traits". Unterm Strich hat der Abend sicher wieder eine Menge hilfreicher Ideen und technischer Anregungen für alle Anwesenden gebracht.

C++ User-Treffen in Düsseldorf am 17.12.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf feierten wir den 3-ten Geburtstag des C++ User-Treffens in Düsseldorf. Wie schon letztes Jahr hatten einige der 13 Teilnehmer Kuchen & Kekse mitgebracht - für unser leibliches Wohl war also gut gesorgt.

Der Abend startete mit einem Rückblick von Jens Weller, der auf die Entwicklung der C++ User-Gruppen in Europa in den letzten 3 Jahren zurückschaute - immerhin war unser Treffen in Düsseldorf vor 3 Jahren zusammen mit einer C++ User-Gruppe in Oslo der Ausgangs-Punkt für viele weitere C++ User-Gruppen Gründungen in Europa (u.a. in Aachen) und die europäische C++ Konferenz Meeting C++ geworden.

Danach startete ich mit dem diesjährigen Weihnachts & Geburtstags C++ Quiz. Wie schon letztes Jahr hatte ich 50 Fragen vorbereitet, die sich aus den verschiedensten Bereichen von C++ zusammensetzten. Und fast immer ging es um die Untiefen von C++. Bestes Beispiel hierfür war eine Frage mit einer Code-Zeile, die die Bemerkung auslöste "Wenn das compiliert verliere ich den Glauben an C++". Lieber Sven, leider musste ich dich entäuschen - die Zeile ist korrektes C++ und compiliert.

Alle Fragen wurden in der Gruppe diskutiert und nur bei wenigen Fragen waren sich alle Anwesenden einig wie die Antwort lautet. Und trotzdem war sie nicht immer richtig. Aber gerade die unterschiedlichsten Erfahrungen der Teilnehmer in Kombination mit den zum Teil "fiesen" Fragen belebten die Diskussionen ungemein und führten zu viel Spaß, aber auch manchem Aha-Erlebnis.

Vor der notwendigen Kuchen- und Keks-Pause hatte ich extra eine "interessante" Frage positioniert. Ich hatte ein C Programm aus dem "The International Obfuscated C Code Contest" kopiert und stellte die Frage, was diese 24 Zeilen extrem unleserlichen C-Codes denn machen. Natürlich hatte keiner der Anwesenden die Chance, das aus dem Code zu erkennen. Und so konnte ich sie mit der Antwort überraschen, dass dies ein kompletter Basic-Interpreter ist. Und in der Pause spielten dann mehrere Teilnehmer "Lunar Landar" - geschrieben in altem Basic, ausgeführt auf einem 24 Zeilen Interpreter.

Leider führten die Einführung von Jens, die Diskussionen und die lange Kuchen- & Keks-Pause dazu, dass wir nach 30 Fragen die 22:00 schon hinter uns gelassen hatten. So entschlossen wir uns, das C++ Quiz abzubrechen - um es wohl beim nächsten Mal zu beenden. Es entwickelten sich noch einige interessante Diskussionen - aber Stück für Stück löste sich das Treffen dann aufgrund der späten Zeit auf.

C++ User-Treffen in Düsseldorf am 19.11.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf hielt Klaus Wittlich den zweiten Teil seines Vortrags über C++ Wartungstechniken. Den ersten Teil hatte er im August gehalten. 11 interessierte C++ Entwickler waren diesmal dabei und lernten, wie man Code noch optimaler strukturiert.

Wie schon im August hatte Klaus keine Präsentation vorbereitet, sondern Quelltext mitgebracht, den er direkt in der IDE ausführte und an den wichtigen Stellen Schritt für Schritt im Debugger durchging. Vielleicht fehlte dadurch manchmal ein schönes Bild - dafür waren die Techniken sehr konkret und konnten im Detail analysiert werden.

Die erste Stunde stand im Zeichen der Template Meta-Programmierung - ohne das Klaus diesen Begriff nutzte. Statt dessen motivierte er mit einem typisches Problem: der Programmierer muss eine Funktion aus allen Basisklassen aufrufen. Hierbei besteht die Gefahr, dass sich die Basisklassen ändern - die Funktionsaufrufe aber nicht angepaßt werden. Ein typisches Wartungsproblem. Klaus zeigte nun in mehreren Stufen, wie Typlisten aufgebaut werden können, diese dann die Basis-Klassen aufnehmen, und der Aufruf der Basis-Klassen-Funktionen über diese Typlisten umgesetzt werden kann. Damit muss nur noch die Typliste der Basisklassen angepaßt werden - das restliche Programm bleibt unberührt - und so möchte man es ja haben.

Eine vergleichbare Lösung zeigte Klaus uns danach für die Member einer Klasse, die nun via Makros in Property-Klassen gekapselt wurden und dann als Gesamtheit in Property-Listen gehalten wurden. So konnten rekursiv Property-Strukturen aufgebaut werden, die dann wieder vom Compiler automatisch abgearbeitet werden konnten. Und wieder mussten nur die Property-Listen aktualisiert werden, während das restliche Programm unverändert bleiben konnte.

Auch die weiteren Themen von Klaus standen ganz im Zeichen von geringerem Wartungs-Aufwand. Wenn möglich sollte der Programmierer möglichst wenig - bis gar nichts - an anderen Stellen ändern müssen, wenn irgendwo eine Modifikation notwändig ist. Klaus stellte dann z.B. vor, wie man Member aus dem normalen Kopier- und Kopier-Zuweisungs-Verhalten herausnimmt, ohne dass man diese impliziten Funktionen explizit implementieren muss. oder wie man z.B. Funktions-Parameter in einem Objekt zusammenfaßt und damit die Funktions-Signaturen gegen Änderungen unempfindlicher macht - nebenbei führte er hier auch nochmal das Builder-Pattern und viele andere Techniken vor. Zum Schluß demostrierte er dann noch, wie man Objekte mit einer Status-Version versehen kann um z.B. Caching-Strategien zu forcieren

Alles in allem war es wieder ein erfolgreicher Abend mit einem bunten Strauß an kleinen und großen Techniken, die alle den Wartungs-Aufwand verringern helfen. Die Diskussionen während des Vortrags zeigten, dass zwar manche Technik schon weit bekannt ist, aber im Detail doch immer wieder Fragen und Ideen entstehen die sie uns unter einem anderen Licht betrachten läßt - und mancher Trick war dem einen oder anderen auch komplett unbekannt. Unterm Strich konnten also alle was Neues lernen.

Den Vortag von Klaus als Quelltexte inkl. Microsoft Visual-Studio Solution-File könnt Ihr hier als 7z Datei downloaden.

C++ User-Treffen in Düsseldorf am 15.10.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf hatten Sven Johannsen und ich ein C++ Code-Dojo vorbereitet. Ein Code-Dojo ist ein Zusammenkommen von Programmierern, die eine konkrete Technik oder allgemein das Programmieren üben und verbessern - und vor allem Spaß haben wollen. 10 Leute waren gekommen, um sich diesen Spaß nicht entgehen zu lassen und teilzunehmen.

Sven und ich hatten einen Code-Dojo Server vorbereitet, und als Aufgabe die Berechnung eines für den Käufer optimalen Preises beim Kauf mehrerer Harry-Potter Bücher. Hierbei gab es Preis-Nachlässe wenn man mehrere unterschiedliche Harry-Potter Bücher kauft, aber nicht bei mehreren Gleichen. Außerdem waren die Nachlässe so gestaffelt (5%, 10%, 20%, 25%), dass die größten Gruppierungen nicht immer den besten Nachlass ergaben - man also letztlich die Gruppierungen durchprobieren musste.

Unser Code-Dojo stand unter dem Zeichen Pair-Programming und TDD (Test-Driven-Development). Es sollten also immer 2 Leute gleichzeitig programmieren, wobei einer der Pilot und der andere der unterstützende Co-Pilot war. Der TDD Ansatz gab vor, dass man zuerst einen weiteren Testfall erstellt, der dafür sorgt das die Tests fehlschlagen (rot). Dann sollte die Implementierung verbessert werden, bis wieder alle Testfälle okay sind (grün). Danach stand immer ein Refactoring an, um die Code immer in einem sehr guten Zustand zu halten. Dank der vorhandenen Testfälle sind beim TDD die Refactorings unproblematisch - sollten aber trotzdem in möglichst kleinen Schritten durchgeführt werden.

Das Code-Dojo lief dann etwas schleppend an, da die Anwesenden erstmal den Zyklus "Test - Implementierung - Refactoring" und vor allem die kleinen Schritte verinnerlichten mussten. Gerade mit den kleinen Schritten taten sich Einige anfangs doch sehr schwer - aber dazu übt man ja. Im Laufe der Zeit lief es dann immer besser. Der Pair-Programming Ansatz wurde dann relativ schnell ignoriert, und die weiteren Schritte fast immer direkt in der großen Gruppe diskutiert. Dies hatte ich schon öfter erlebt, und wie schon früher empfand ich gerade diese Diskussionen als sehr lehrreich, da nun jeder jederzeit Ideen und Meinungen beisteuern konnte, die direkt diskutiert wurden.

Stück für Stück entwickelte sich so das Programm. Nach rund n1 1/2 Stunden hörten wir dann auf - nicht, weil die Aufgabe gelöst war, sondern da unsere Zeit um war - und wir den Rest noch für eine kurze Retrospektive nutzen wollten. Wie schon häufiger war die Hauptfrage in der Retrospektive, ob man mit TDD wirklich echte Programme entwickeln kann. Auch unsere Implementierung hatte wieder einige Umwege genommen, die man vielleicht mit dem direkten Blick für das gesamte Problem nicht genommen hätte. Auf der anderen Seite waren diese "Umwege" auch notwändig gewesen, um die Aufgabe wirklich zu verstehen - vielleicht hätte man sie sonst auch gemacht, nur anders. Einig waren wir uns aber alle, dass ein Code-Dojo eine interessante Trainings-Technik ist, bei der doch alle was neues gelernt haben.

Unten findet sich eine mögliche erste fehlerhafte Lösung der Aufgabe, die die optimale Gruppierung noch nicht berücksichtigt. Da wir beim C++ User-Treffen eine andere Schnittstelle (mit Enums und Vektor) gewählt hatten, enthält der zweite Quelltext die Lösung mit einem entsprechenden Interface. Alle Tests sind hierbei als Asserts ausgelegt. Eine vollständig korrekte Lösung mit optimaler Gruppierung wird in den nächsten Tagen nachgereicht. 

// Erste Loesung der Buch-Preis Aufgabe - noch ohne optimale Gruppierung

#include <cassert>
#include <algorithm>
#include <array>
#include <iostream>

using namespace std;

const int europrice  = 8;
const int price1 = 1 * europrice * 100;
const int price2 = 2 * europrice *  95;
const int price3 = 3 * europrice *  90;
const int price4 = 4 * europrice *  80;
const int price5 = 5 * europrice *  75;

int calcPriceInCent(array<int, 5> arg)
{
   sort(begin(arg), end(arg));

   int count = arg[0];
   int res = count * price5;

   count = arg[1] - arg[0];
   res += count * price4;

   count = arg[2] - arg[1];
   res += count * price3;

   count = arg[3] - arg[2];
   res += count * price2;

   count = arg[4] - arg[3];
   res += count * price1;

   return res;
}

int main()
{
   cout << "Tests for \"Harry Potter Books\" Code-Dojo" << endl;

   // 0 books
   assert(0 == calcPriceInCent({ 0, 0, 0, 0, 0 }));

   // 1 book
   assert(800 == calcPriceInCent({ 1, 0, 0, 0, 0 }));
   assert(800 == calcPriceInCent({ 0, 1, 0, 0, 0 }));
   assert(800 == calcPriceInCent({ 0, 0, 1, 0, 0 }));
   assert(800 == calcPriceInCent({ 0, 0, 0, 1, 0 }));
   assert(800 == calcPriceInCent({ 0, 0, 0, 0, 1 }));

   // 2 books - all different
   assert(1520 == calcPriceInCent({ 1, 1, 0, 0, 0 }));
   assert(1520 == calcPriceInCent({ 0, 1, 1, 0, 0 }));
   assert(1520 == calcPriceInCent({ 0, 0, 1, 1, 0 }));
   assert(1520 == calcPriceInCent({ 0, 0, 0, 1, 1 }));
   assert(1520 == calcPriceInCent({ 0, 1, 0, 0, 1 }));

   // 2 books - all identical
   assert(1600 == calcPriceInCent({ 2, 0, 0, 0, 0 }));
   assert(1600 == calcPriceInCent({ 0, 2, 0, 0, 0 }));
   assert(1600 == calcPriceInCent({ 0, 0, 2, 0, 0 }));
   assert(1600 == calcPriceInCent({ 0, 0, 0, 2, 0 }));
   assert(1600 == calcPriceInCent({ 0, 0, 0, 0, 2 }));

   // 3 books - all different
   assert(2160 == calcPriceInCent({ 1, 1, 1, 0, 0 }));
   assert(2160 == calcPriceInCent({ 0, 1, 1, 1, 0 }));
   assert(2160 == calcPriceInCent({ 0, 0, 1, 1, 1 }));
   assert(2160 == calcPriceInCent({ 1, 0, 0, 1, 1 }));
   assert(2160 == calcPriceInCent({ 0, 1, 1, 0, 1 }));

   // 3 books - groups with 1 & 2
   assert(2320 == calcPriceInCent({ 1, 2, 0, 0, 0 }));
   assert(2320 == calcPriceInCent({ 0, 0, 1, 2, 0 }));
   assert(2320 == calcPriceInCent({ 0, 2, 0, 0, 1 }));
   assert(2320 == calcPriceInCent({ 2, 0, 0, 1, 0 }));
   assert(2320 == calcPriceInCent({ 0, 1, 2, 0, 0 }));
   assert(2320 == calcPriceInCent({ 0, 0, 0, 1, 2 }));

   // 3 books - all identical
   assert(2400 == calcPriceInCent({ 3, 0, 0, 0, 0 }));
   assert(2400 == calcPriceInCent({ 0, 3, 0, 0, 0 }));
   assert(2400 == calcPriceInCent({ 0, 0, 3, 0, 0 }));
   assert(2400 == calcPriceInCent({ 0, 0, 0, 3, 0 }));
   assert(2400 == calcPriceInCent({ 0, 0, 0, 0, 3 }));

   // 4 books - all different
   assert(2560 == calcPriceInCent({ 1, 1, 1, 1, 0 }));
   assert(2560 == calcPriceInCent({ 0, 1, 1, 1, 1 }));
   assert(2560 == calcPriceInCent({ 1, 0, 1, 1, 1 }));
   assert(2560 == calcPriceInCent({ 1, 1, 0, 1, 1 }));
   assert(2560 == calcPriceInCent({ 1, 1, 1, 0, 1 }));

   // 4 books - groups with 1, 1 & 2
   assert(2960 == calcPriceInCent({ 1, 1, 2, 0, 0 }));
   assert(2960 == calcPriceInCent({ 0, 0, 1, 1, 2 }));
   assert(2960 == calcPriceInCent({ 0, 2, 1, 0, 1 }));
   assert(2960 == calcPriceInCent({ 2, 1, 0, 1, 0 }));
   assert(2960 == calcPriceInCent({ 1, 0, 0, 2, 1 }));

   // 4 books - groups with 2 & 2
   assert(3040 == calcPriceInCent({ 2, 2, 0, 0, 0 }));
   assert(3040 == calcPriceInCent({ 0, 0, 2, 2, 0 }));
   assert(3040 == calcPriceInCent({ 0, 2, 0, 0, 2 }));
   assert(3040 == calcPriceInCent({ 2, 0, 2, 0, 0 }));
   assert(3040 == calcPriceInCent({ 0, 0, 0, 2, 2 }));

   // 4 books - groups with 1 & 3
   assert(3120 == calcPriceInCent({ 1, 3, 0, 0, 0 }));
   assert(3120 == calcPriceInCent({ 0, 0, 1, 3, 0 }));
   assert(3120 == calcPriceInCent({ 0, 0, 1, 0, 3 }));
   assert(3120 == calcPriceInCent({ 0, 1, 3, 0, 0 }));
   assert(3120 == calcPriceInCent({ 3, 0, 0, 0, 1 }));

   // 4 books - all identical
   assert(3200 == calcPriceInCent({ 4, 0, 0, 0, 0 }));
   assert(3200 == calcPriceInCent({ 0, 4, 0, 0, 0 }));
   assert(3200 == calcPriceInCent({ 0, 0, 4, 0, 0 }));
   assert(3200 == calcPriceInCent({ 0, 0, 0, 4, 0 }));
   assert(3200 == calcPriceInCent({ 0, 0, 0, 0, 4 }));

   // 5 books - all different
   assert(3000 == calcPriceInCent({ 1, 1, 1, 1, 1 }));

   // 5 books - groups with 1, 1, 1 & 2
   assert(3360 == calcPriceInCent({ 1, 1, 1, 2, 0 }));
   assert(3360 == calcPriceInCent({ 1, 2, 0, 1, 1 }));
   assert(3360 == calcPriceInCent({ 0, 1, 1, 1, 2 }));
   assert(3360 == calcPriceInCent({ 1, 1, 2, 0, 1 }));
   assert(3360 == calcPriceInCent({ 2, 0, 1, 1, 1 }));

   // 5 books - groups with 1, 2 & 2
   assert(3680 == calcPriceInCent({ 1, 2, 2, 0, 0 }));
   assert(3680 == calcPriceInCent({ 0, 0, 1, 2, 2 }));
   assert(3680 == calcPriceInCent({ 2, 1, 0, 2, 0 }));
   assert(3680 == calcPriceInCent({ 2, 2, 0, 0, 1 }));
   assert(3680 == calcPriceInCent({ 0, 0, 2, 1, 2 }));

   // 5 books - groups with 1, 1 & 3
   assert(3760 == calcPriceInCent({ 1, 1, 3, 0, 0 }));
   assert(3760 == calcPriceInCent({ 0, 0, 1, 1, 3 }));
   assert(3760 == calcPriceInCent({ 3, 0, 1, 0, 1 }));
   assert(3760 == calcPriceInCent({ 0, 1, 1, 3, 0 }));
   assert(3760 == calcPriceInCent({ 1, 3, 0, 0, 1 }));

   // 5 books - groups with 2 & 3
   assert(3840 == calcPriceInCent({ 2, 3, 0, 0, 0 }));
   assert(3840 == calcPriceInCent({ 0, 0, 2, 3, 0 }));
   assert(3840 == calcPriceInCent({ 0, 0, 3, 0, 2 }));
   assert(3840 == calcPriceInCent({ 0, 2, 0, 0, 3 }));
   assert(3840 == calcPriceInCent({ 3, 0, 0, 2, 0 }));

   // 5 books - groups with 1 & 4
   assert(3920 == calcPriceInCent({ 1, 4, 0, 0, 0 }));
   assert(3920 == calcPriceInCent({ 0, 0, 1, 4, 0 }));
   assert(3920 == calcPriceInCent({ 0, 4, 0, 0, 1 }));
   assert(3920 == calcPriceInCent({ 4, 0, 0, 1, 0 }));
   assert(3920 == calcPriceInCent({ 0, 0, 0, 4, 1 }));

   // 5 books - all identical
   assert(4000 == calcPriceInCent({ 5, 0, 0, 0, 0 }));
   assert(4000 == calcPriceInCent({ 0, 5, 0, 0, 0 }));
   assert(4000 == calcPriceInCent({ 0, 0, 5, 0, 0 }));
   assert(4000 == calcPriceInCent({ 0, 0, 0, 5, 0 }));
   assert(4000 == calcPriceInCent({ 0, 0, 0, 0, 5 }));

   // 8 books - groups with 1, 1, 2, 2 & 2
   // Possible: 5 + 3 => 3000 + 2160 = 5160
   //           4 + 4 => 2560 + 2560 = 5120 <<<< Better!
   assert(5160 == calcPriceInCent({ 1, 1, 2, 2, 2 }));   // Still wrong grouping

   cout << "All tests successfull" << endl;
}



// Erste Loesung der Buch-Preis Aufgabe - noch ohne optimale Gruppierung
// Hier mit der Schnittstelle vom Code-Dojo mit Vektor und Enum

#include <cassert>
#include <algorithm>
#include <array>
#include <iostream>
#include <map>
#include <vector>

using namespace std;

const int europrice  = 8;
const int price1 = 1 * europrice * 100;
const int price2 = 2 * europrice *  95;
const int price3 = 3 * europrice *  90;
const int price4 = 4 * europrice *  80;
const int price5 = 5 * europrice *  75;

int calcPriceInCentOld(array<int, 5> arg)
{
   sort(begin(arg), end(arg));

   int count = arg[0];
   int res = count * price5;

   count = arg[1] - arg[0];
   res += count * price4;

   count = arg[2] - arg[1];
   res += count * price3;

   count = arg[3] - arg[2];
   res += count * price2;

   count = arg[4] - arg[3];
   res += count * price1;

   return res;
}

enum Book { B1, B2, B3, B4, B5 };

int calcPriceInCent(const vector<Book>& v)
{
   array<int, 5> counts = {0};
   for_each(cbegin(v), cend(v), [&counts](Book book){ ++counts[book]; });
   return calcPriceInCentOld(counts);
}

int main()
{
   cout << "Tests for \"Harry Potter Books\" Code-Dojo" << endl;

   // 0 books
   assert(0 == calcPriceInCent({}));
   
   // 1 book
   assert(800 == calcPriceInCent({ B1 }));
   assert(800 == calcPriceInCent({ B2 }));
   assert(800 == calcPriceInCent({ B3 }));
   assert(800 == calcPriceInCent({ B4 }));
   assert(800 == calcPriceInCent({ B5 }));
   
   // 2 books - all different
   assert(1520 == calcPriceInCent({ B1, B2 }));
   assert(1520 == calcPriceInCent({ B2, B3 }));
   assert(1520 == calcPriceInCent({ B3, B4 }));
   assert(1520 == calcPriceInCent({ B4, B5 }));
   assert(1520 == calcPriceInCent({ B2, B5 }));

   // 2 books - all identical
   assert(1600 == calcPriceInCent({ B1, B1 }));
   assert(1600 == calcPriceInCent({ B2, B2 }));
   assert(1600 == calcPriceInCent({ B3, B3 }));
   assert(1600 == calcPriceInCent({ B4, B4 }));
   assert(1600 == calcPriceInCent({ B5, B5 }));

   // 3 books - all different
   assert(2160 == calcPriceInCent({ B1, B2, B3 }));
   assert(2160 == calcPriceInCent({ B2, B3, B4 }));
   assert(2160 == calcPriceInCent({ B3, B4, B5 }));
   assert(2160 == calcPriceInCent({ B1, B4, B5 }));
   assert(2160 == calcPriceInCent({ B2, B3, B5 }));

   // 3 books - groups with 1 & 2
   assert(2320 == calcPriceInCent({ B1, B1, B2 }));

   // 3 books - all identical
   assert(2400 == calcPriceInCent({ B1, B1, B1 }));

   // 4 books - all different
   assert(2560 == calcPriceInCent({ B1, B2, B3, B4 }));

   // 4 books - groups with 1, 1 & 2
   assert(2960 == calcPriceInCent({ B1, B2, B4, B4 }));

   // 4 books - groups with 2 & 2
   assert(3040 == calcPriceInCent({ B4, B5, B4, B5 }));

   // 4 books - groups with 1 & 3
   assert(3120 == calcPriceInCent({ B2, B4, B4, B4 }));

   // 4 books - all identical
   assert(3200 == calcPriceInCent({ B1, B1, B1, B1 }));

   // 5 books - all different
   assert(3000 == calcPriceInCent({ B1, B2, B3, B4, B5 }));

   // 5 books - groups with 1, 1, 1 & 2
   assert(3360 == calcPriceInCent({ B1, B2, B3, B4, B4 }));

   // 5 books - groups with 1, 2 & 2
   assert(3680 == calcPriceInCent({ B1, B3, B3, B5, B5 }));

   // 5 books - groups with 1, 1 & 3
   assert(3760 == calcPriceInCent({ B1, B2, B3, B3, B3 }));

   // 5 books - groups with 2 & 3
   assert(3840 == calcPriceInCent({ B1, B1, B4, B4, B4 }));

   // 5 books - groups with 1 & 4
   assert(3920 == calcPriceInCent({ B1, B4, B4, B4, B4 }));

   // 5 books - all identical
   assert(4000 == calcPriceInCent({ B5, B5, B5, B5, B5 }));

   // 8 books - groups with 1, 1, 2, 2 & 2
   // Possible: 5 + 3 => 3000 + 2160 = 5160
   //           4 + 4 => 2560 + 2560 = 5120 <<<< Better!
   assert(5160 == calcPriceInCent({ B1, B2, B3, B4, B5, B3, B4, B5 }));   // Still wrong grouping

   cout << "All tests successfull" << endl;
}

C++ User-Treffen in Düsseldorf am 17.09.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf berichtete Max Neunhöffer von den Erfahrungen bei der Umstellung der Entwicklung der "ArangoDB" auf C++11. Leider waren diesmal nur 10 C++ Entwickler anwesend.

ArangoDB ist eine Open-Source Multi-Purpose NoSQL Datenbank - und da nicht jeder mit all den Schlagwörtern etwas anfangen konnte, begann der Vortrag von Max mit einer kurzen Einführung in NoSQL-Datenbanken und die typischen NoSQL-Konzepte und ihre Abgrenzung zu relationalen Datenbanken. Detaillierter führte Max hier vor allem die Themen Skalierbarkeit und Verteilung auf viele Server aus - Themen in denen sich NoSQL-Datenbanken stark von den Relationalen unterscheiden. Natürlich blieb es hierbei nicht aus, dass Max auch ausführlicher auf die Konzepte und Vorteile der ArangoDB einging.

Danach kam er zum für uns eigentlich interessantesten Bereich des Vortrags: die Erfahrungen beim Übergang von C bzw. C++03 auf C++11. Hierbei stellte er zuerst die Probleme vor, die sie beim Umstieg auf C++11 hatten. Haupt-Problem war die Compiler-Unterstützung auf vielen älteren Linux-Plattformen und unter Windows (das aktuelle Microsoft Visual-Studio 2013 hat leider noch viele Lücken bzgl. C++11). Für Linux wurde mindestens der GCC in Version 4.8 benötigt, und für viele von ArangoDB unterstützten Linux-Distributionen gab es keinen fertigen Binär-Pakete des GCC 4.8 oder neuer. Das hieß dann: selber bauen - und zum Teil war dies wohl kein ganz leichter Job. Die Linux-Distribution "Mandriva 2011" blieb dabei auch auf der Strecke - seit Version 2.1 von ArangoDB wird Mandriva nicht mehr unterstützt. Nachdem dann alle notwendigen Compiler vorhanden waren, mussten die Build-Skripte angepaßt werden. Was so einfach klingt, zeigte in der Praxis dann eine Menge Detail-Probleme. Vor allem die langen Turn-Around Zeiten machen solche Umstellungen oft zu einem langwierigen Prozeß - ich kann dies aus eigener Erfahrung nur bestätigen.

Ein weiteres Problem waren die von Bison und Yacc erzeugten C und C++ Quelltexte, die voll mit dem in C++11 nun deprecated Schlüsselwort "register" waren - was zu vielen unerwünschten Warnungen führte, d.h. die Quellen mussten angepaßt werden. Auch andere Quelltexte mussten modifiziert werden, da sich z.B. einzelne Typ-Casts oder Using-Anweisungen auf den neueren Compilern und den verschiedenen Plattformen anders (korrekter) verhielten.

Auf der Positiv-Seite standen dann viele neue Sprach-Features, die die Entwicklung zum Teil stark vereinfachten und sicherer machten. Max stellte seine persönlichen 10 Favoriten der neuen C++ Features vor, u.a. "auto", "decltype", "Lambdas", "Hash-Container", "Smart-Pointer", und einige mehr. Danach listete er weitere neue C++11 Sprach-Feature auf, der sie als hilfreich empfunden haben - aber nicht so wichtig sind. Diese subjektiven Listen führten naturgemäß zu einer längeren Diskussion, denn alle anwesenden Entwickler hatten schon ihre eigenen Erfahrungen mit dem Umstieg auf C++11 gemacht, und jeder empfand andere neue C++11 Sprach-Features als besonders hilfreich. Es war interessant - und zum Teil sehr lehrreich - zu hören, welche unterschiedlichen Erfahrungen gemacht worden sind.

Danach zeigte Max noch einigen beispielhaften Code, der durch die Verwendung von C++11 einfacher und besser geworden war. Und jetzt ging die Diskussion erst richtig los. Wenn Entwickler richtigen Code sehen, dann können sie nicht ruhig bleiben: jeder hatte Fragen, warum Dinge so gelöst worden sind. Und natürlich hatte jeder Anmerkungen, welcher Stil besser lesbar ist, wie sich Probleme besser lösen lassen, wo in diesem Code Probleme lauern könnten, wo Code-Stellen nicht optimal sind, usw. Gerade z.B. die Verwendung von "auto" führte zu mancher Meinungs-Äußerung und Diskussion - wer hätte das bei einem so einfachen Sprachmittel gedacht? Ich liebe diesen Gedanken-Austausch: selbst wenn mancher Stil subjektiv ist, und es für viele Fragen keine eindeutig beste Lösung gibt - man lernt ganz viel und bekommt ganz neue Sichtweisen vermittelt. Allein hierfür hätte sich der Abend gelohnt.

Unterm Strich war der Abend wieder ein voller Erfolg, nur schade dass nicht mehr Entwickler da waren. Allein schon die Ausführung zu den NoSQL-Datenbanken und ArangoDB hätten den Abend lohnenswert gemacht - mit den spannenden Diskussionen um die C++11 Sprachmittel und ihre Anwendungen im konkreten Code war er mehr als das.

C++ User-Treffen in Düsseldorf am 20.08.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf stellte Klaus Wittlich C++ Wartungstechniken aus seiner täglichen Praxis vor. Hierbei ging es zum einen darum Code zu schreiben, der weniger Fehler enthält - zum anderen dann darum die leider trotzdem auftretenden Fehler effizient zu finden. 16 neugierige C++ Entwickler waren gekommen um hoffentlich etwas für ihre tägliche Arbeit mit nach Hause nehmen zu können.

Im Gegensatz zu den meisten anderen Vorträgen hatte Klaus keine Präsentation, sondern statt dessen einen Dialog mit vielen Buttons vorbereitet - für jedes Thema einen Button. Der Klick auf den Button brachte ihn dann direkt in den entsprechenden Code und löste dort einen Breakpoint aus. Das Thema selber fand sich dann in den Kommentaren und natürlich im Code wieder. Überhaupt zeichnete sich der Vortrag durch viel Praxis-Nähe aus: quasi alle Techniken wurden direkt im Code und/oder im Debugger gezeigt.

Den Anfang machten einige Code-Konventionen, dann ging es um Kommentare . Hier fielen vor allem die Kommentar-Switches auf, bei denen Klaus mit einem einzigen Zeichen Bereiche ein- bzw. auskommentieren konnte, bzw. sogar zwischen Implementierung wechseln konnte. Auch für den ein oder anderen neu waren all die Möglichkeiten, "Kommentare" im Quelltext unterzubringen, die gar keine Kommentare im herkömmlichen Sinne sind. Danach ging es um Techniken Fehler zu Debuggen die erst beim n-ten Durchlauf auftreten. Da dies ein typisches tägliches Problem ist, konnten hier viele Anwesende mitdiskutieren und weitere Techniken beisteuern. Auch die Techniken im Speicher-Management Umfeld und die Unterstützung des Microsoft Visual-Studios war für viele neu und interessant. Als nächstes setzte Klaus CRTP ein um "böse" Objekte zu identifizieren - in Verbindung mit einer Art "Tracer" auch noch nach ihrer Freigabe. Anschließend führte er Techniken vor um Änderungen an Enum-Definitionen automatisch zu erkennen. Hier ging es sowohl um Techniken, die erst zur Laufzeit zuschlagen, als auch welche die schon zur Compile-Zeit aktiv sind. Den Abschluß des Tages bildete dann eine Art Versions-Kontrolle für Klassen zur Compile-Zeit, die automatisch auf Änderungen an kritischen Stellen (wie Konstruktoren, Create-, Swap- oder Serialisierungs-Funktionen) hinwies.

Die Fülle an Ideen und Techniken forderte ihren Tribut in Form von Zeit: es war fast 22:30 als Klaus all diese Themen abgearbeitet hatte. Und trotzdem hatte er erst knapp über die Hälfte der Buttons angeklickt - es blieb also noch Stoff für einen weiteren Abend. Voraussichtlich im November wird Klaus daher seine restlichen C++ Wartungstechniken vorstellen - wir freuen uns darauf.

Den Vortag von Klaus als Quelltexte inkl. Microsoft Visual-Studio Solution-File könnt Ihr hier als 7z Datei downloaden.

C++ User-Treffen in Düsseldorf am 16.07.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf war ich leider nicht anwesend. Wie geplant, fand eine Video-Konferenz mit Michael Wong über das letzte C++ Standardisierungs-Treffen in Rapperswil (Schweiz) und die aktuellen Themen der C++ Standardisierung statt. Da ich leider selber nicht dabei war, kann ich diesmal nicht mehr berichten.

C++ User-Treffen in Düsseldorf am 18.06.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf stellte uns Mirco Müller die "2D-Grafikbibliothek Cairo" vor. Immerhin 15 C++ Entwickler wollten diesmal nicht nur spitze Klammern sehen (wie beim letzen Mal), sondern konkrete Grafiken und ihre Implementierungen.

Mirco Müller enttäuschte sie nicht. Nach einer kurzen Einführung in die Geschichte und die Ideen von Cairo legte er direkt mit einem Live-Coding los - und implementierte einige einfache Beispiele. Hier konnte Mirco zeigen, wie die vorher erläuterten Ideen von Cairo in der Praxis umgesetzt werden müssen. Durch diese ersten einfachen Beispiele konnten alle Anwesenden alle Schritte problemlos nachvollziehen.

Für etwas Erheiterung sorgte die C-API von Cairo. Es gibt zwar auch einen C++ Wrapper "CairoMM", aber Mirco stellte die Original C-API von Cairo vor. In C++ wären die Beispiele doch einiges kürzer und besser lesbar ausgefallen. Vor allem aber fehlerfreier. Während nämlich das Image-Target keine explizites Schließen benötigt - war dies beim PDF-Target anders. Und so fehlte das Schließen dann auch, und das erzeugte PDF war fehlerhaft. Erst nach einigen Augenblicken und Versuchen fand Mirco das Problem. In C++ mit RAII wäre dies niemals ein Problem gewesen - C++ verhindert einfach ganz viele dumme Fehler.

Nach dem Live-Coding stellte Mirco einige abgedrehtere Beispiele vor, z.B. einen Film-Sequenz-Zähler, eine schwebende Uhr, ein animiertes Netz, ein animiertes Dock, und vieles mehr. Hier zeigten sich dann die echten Vorteile einer solchen 2D-Grafikbibliothek, vor allem da sich Cairo z.B. problemlos mit OpenGL verbinden läßt.

Mit dem Ende des Vortrags ging der Abend fließend in die Diskussion über. Während sich einige Leute direkt mit Cairo weiterbeschäftigten und versuchten SVG-Grafiken darzustellen (was dann mit Mircos Hilfe auch schnell gelang), tauschten sich die anderen über Code-Dojos, C++11 und Informatik-Studiengänge aus.

Hier einige weiterführende Links:

C++ User-Treffen in Düsseldorf am 21.05.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf gab es eine "Einführung in C++ Expression-Templates" von Detlef Wilkening. Immerhin 13 Interessierte waren bereit, sich auf etwas Gehirn-Verdreherei einzulassen.

Da Expression-Templates nicht so bekannt sind, und sie durch die vielen Template-Instanziierungen verwirrend sein können, hatte ich mich entschlossen, eine langsame Schritt für Schritt Einführung zu machen. Ich fing also ganz ganz einfach mit einem ersten sinnlosen Ausdruck (einer Variablen "x", die nur für die Eingabe steht) an, und erweiterte dieses Beispiel langsam. Erst eine Erweiterung auf einen etwas sinnvolleren Quadrat-Ausdruck, dann eine Verallgemeinerung mit Templates, um die Quadrat-Ausdrücke beliebig schachteln zu können. Zur Übung ein weiterer unärer Ausdruck, dann die Erweiterung auf binäre Ausdrücke, und das Ausrollen auf alle grundlegenden mathematischen Operatoren.

Bevor es weiterging, haben wir uns dann erstmal um einige Probleme der bisherigen Implementierung im Zusammenspiel mit echtem Code gekümmert: sie erkannt, analysiert und beseitigt, und dann noch die Gemeinsamkeiten aller Klassen in allgemeines Bibliotheks-Klassen ausgelagert. Obwohl der Code danach etwas verwirrender aussah, wurde doch klar, dass er prinzipiell noch der alte Code war.

Nachdem wir also verstanden hatten, was Expression-Templates sind, haben wir uns einige typische Anwendungs-Beispiele angeschaut. Zuerst haben wir unser eignes "std::bind" geschrieben, dann Kopien und sinnlose Schleifen in mathematischen Berechnungen bei Vektoren und Matrizen beseitigt, und zum Schluß noch mit einigen DSELs ("domain specific embeded languages") gespielt.

Selbst wenn das Thema nicht einfach war - aufgrund der Schritt für Schritt Einführung konnte jeder folgen, und am Ende des Tages hatten alle Expression-Templates verstanden. Leider hat der Vortrag einiges über 2 Stunden gedauert - und so blieb hinterher keine Zeit mehr für große Diskussionen - der Abend war dann schnell vorbei.

C++ User-Treffen in Düsseldorf am 16.04.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren 16 Interessierte gekommen, um Jens Weller über "0xBADCODE" reden zu hören.

Im Vorfeld war niemandem so richtig klar gewesen, was uns bei dem Thema erwartet - die Meisten hatten wohl mit einer Menge Beispiele von schlechtem Code gerechnet. Aber Jens überraschte uns mit einem Vortrag mit sehr wenig Code. Natürlich tauchten auch typische Bad-Code Pattern in C++ auf, aber Jens konzentrierte sich mehr auf die Fragen, wie schlechter Code entsteht und was man dagegen machen kann. So entsteht schlechter Code laut Jens u.a. durch Zeitdruck, oder der Bevorzugung von neuen Features oder Bugfixes vor Unit-Tests oder Refactorings. Auch ein tpyischer Auslöser für schlechten Code ist das mangelnde Wissen vieler C++ Programmierer über die Sprache und "modernes C++" - viele sehen in C++ eben nur ein Tool und daher keine Notwendigkeit sich beständig darin weiterzuentwickeln.

Jens Vorschläge waren dann ganz konsequent: macht dem Management klar, dass sich durch schlechten Code technische Schulden anhäufen, die hinterher richtig teuer werden. Versucht die Kultur der Firma zu ändern, dass Refactorings und Unit-Tests selbstverständlich werden, und seht zu dass ihr ständig was Neues über die Sprache lernen könnt und am Ball bleibt. Im Notfall muss man die Konsequenz ziehen, und sich eine neue Arbeitsstelle suchen.

Schon während des Vortrags hatte es manche Frage und einige Hinweise gegeben - aber nach dem Vortrag ging die Diskussion richtig los. Mehr oder weniger jeder konnte was zu diesem Thema aus wohl meist leidvoller Erfahrung beitragen.

Für mich blieb leider während und auch nach dem Vortrag die Frage unbeantwortet, wie man die Leute dazu bringen kann, mehr Lust und Zeit in ihre Fortbildung zu investieren - eben z.B. in C++ aber auch in andere technische programmier-relevante Themen. Wieviele Programmierer kommen z.B. nie zu einem C++ User-Treffen und verpassen so die Chance auf unterhaltsame Diskussionen und viele Neuigkeiten.

Unterm Strich war es sicher nicht der Vortrag, den Mancher erwartet hatte. Aber er war spannend und interessant, und die persönlichen Beiträge der Anwesenden zeigten, wie sehr wir alle von "0xBADCODE" betroffen sind.

C++ User-Treffen in Düsseldorf am 19.03.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf ging es wie im Oktober 2013 um Exceptions. Im Gegensatz zu damals lag der Focus des Vortrags von Frank Birbacher diesmal auf Exception-Garantien und ihre Umsetzung in C++. Immerhin 15 C++ Interessierte waren gekommen, um sich tiefer mit diesem wichtigen aber auch gern ignorierten Thema auseinander zu setzen.

Nach einigen einleitenden Folie (gerade auch bzgl. Exceptions in Destruktoren), führte Frank im Gegensatz zu vielen anderen Einführungen ins Exception-Handling die 4 Exception-Garantien (no-fail Garantie, starke Garantie, Basis-Garantie und kein Garantie) nicht theoretisch ein und zeigte hinterher Praxis-Beispiele - sondern stellte sich direkt der Herausforderung eine eigene Stack-Klasse zu schreiben und zeigte für einzelne Funktionen (wie z.B. Konstruktor, push und pop), welche Exception-Garantie eine naive Implementierung erfüllt (bzw. eben nicht erfüllt), und wie man den Code dann exception-sicher macht. Hierbei kristallisierten sich einzelne Muster heraus, mit denen man typischerweise guten exception-sicheren Code schreiben kann.

Danach ging Frank auf die speziellen Funktionen von Klassen ein (Default-Konstruktor, Kopier-Konstruktor, Move-Konstruktor, Kopier-Zuweisungs-Operator, Move-Zuweisungs-Operator, Destruktor und die Swap-Funktion) und beschrieb, welche dieser Funktionen eine no-fail Garantie haben müssen oder sollten, bzw. wie man sie aufeinander abbilden kann und welche Exception-Garantien dabei dann typischerweise wie erfüllt werden.

Schon während des Vortrags hatte es manche Nachfrage und Diskussion gegeben. Hinterher entwickelte sich dann eine rege Diskussion, die sich nicht nur um Exceptions drehte, sondern z.B. auch um die Umsetzung von Variadic Templates in verschiedenen Microsoft Compiler Versionen und die Erkenntnis das "Unendlich jetzt gleich 5 ist" (okay, kann man nur verstehen, wenn man da war oder das Hintergrund Wissen bzgl. Variadic-Templates und MS-Compilern hat), oder die Value-Implementierung in Maps und ihre Konsequenzen, oder auch welche C++ Konferenzen denn demnächst anstehen.

Wie eigentlich immer - ein interessanter und kurzweiliger Abend, wo alle die nicht da waren was verpaßt haben.

C++ User-Treffen in Düsseldorf am 19.02.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf konnte ich leider nicht selber dabei sein. Ich wäre gerne anwesend gewesen, da mich eine C++ Code-Dojo Session sehr gereizt hätte. Aber es hat nicht sollen sein. Der Bericht vom C++ User-Treffen geht daher auf Sven Johannsen zurück, der so nett war, ihn für mich zu verfassen.

Vor der Coding Session berichtete Jens Weller noch kurz über den aktuellen Stand der Meeting-C++ 2014.

Für das C++ User-Treffen hatte Frank Birbacher eine Coding Dojo Session in C++ für uns vorbereitet. In einer kurzen Einführung erklärte Frank die Begriffe Dojo, Kata, Randorie und setzte sie in Bezug zum Programmieren. Hinzu kam der Bezug zum Test Driven Development (TDD) und Pair Programming (Navigator und Driver), da diese Techniken in diesem Coding Dojo eingesetzt werden sollten.

Leider war die Seite http://www.cyber-dojo.org/ an diesem Abend nicht online. Daher musste das Dojo mittels einer herunter geladenen Virtual-Machine durchgeführt werden.

Als Kata wurde Tennis ausgewählt. Die Spielstände sollte wie im Tennis als "love-fifteen", "thirty-forty", "deuce" usw. ausgegeben werden. 2 Teilnehmer kamen nach vorne und begannen zu programmieren. Dabei wurde nach den Regeln von TDD vorgegangen: Erst musste ein Test geschrieben werden der fehlschlägt, dieser wurde gefixt, und dann wurde das Ergebnis refactort. Anschliessend (und natürlich auch zwischendurch) wurde der erstellte Code in der gesamten Runde diskutiert. Nach ein bis zwei neuen Test wurde der Navigator zum Driver und jemand anderes aus der Gruppe zum Navigator. Nach und nach wurde die ganze Gruppe einmal durchgewechselt, und jeder war mal Navigator bzw. Driver. Am Schluß wurden wurden die gemachten Erfahrungen gesammelt und in einer MindMap visualisiert.

Wer an mehr detaillierten Informationen zu Coding-Dojos - dem empfehle ich das Buch "The Coding Dojo Handbook" von Emily Bache.

C++ User-Treffen in Düsseldorf am 15.01.2014

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf hatte Jens Weller von einen Vortrag vorbereitet, der die wichtigsten Aussagen der Keynotes der "Meeting C++ 2013" von Eric Niebler und Tony van Eerd enthielt. Er nannte ihn dementsprechend auch "Was Eric und Tony sagten". 13 C++ Interessierte waren zum Chaosdorf gekommen, um mehr über Schnittstellen- und Bibliotheks-Design zu hören.

Jens stellte in seinem Vortrag zuerst die 11 Guidelines von Eric zu den Themen Funktions-Parameter-Übergabe, Statusbehaftete-Algorithmen, Klassen-Design, Bibliotheks-Design und -Versionierung vor. Die Folien der Keynote mit den Guidelines stehen auf Meeting C++ zur Verfügung. Während einige Guidelines selbstverständlich waren, wurden andere von den Zuhörern heftig diskutiert - zum einen um ihren Hintergrund zu verstehen, zum anderen waren sie nicht immer unstrittig.

Danach wechselte Jens in seinem Vortrag zu der Keynote von Tony van Eerd, dessen Keynote-Folien auch auf der Meeting C++ Seite zur Verfügung stehen. Aufgrund der mangelnden Substanz von Tony's Keynote (siehe auch mein Bericht von der "Meeting C++ 2013)", hatte Jens hier nicht wirklich Viel zu berichten.

Schon während des Vortrags hatte es einige Diskussionen gegeben, die sich aus dem Vortrag ergeben hatten. Nach dem Vortrag wurden sie weitergeführt. So stellte sich z.B. die Frage, ob ein Vector von Unique-Ptr copy-constructible ist. Nun ist er das natürlich nicht - wie auch? Aber welchen Wert gibt "std::is_copy_constructible" zurück? Es ist fehlerhafterweise "true", wie wir spontan mit einem GCC 4.8.1 überprüft haben. Und auch unsere sofortige Recherche im aktuellen C++11 Standard zeigte: "true" ist zwar richtig bzgl. des Standards, aber eben falsch bzgl. der Realität. Wir sahen hier eine Lücke im Standard, und diskutierten dann mehrere Ideen, wie man dies verbessern könnte. Aber auch andere - nicht so abgedrehte Themen - wurden nach dem Vortrag diskutiert: der Einstieg in Qt, Initialisierungs-Listen, Änderungen durch C++14, und vieles mehr.

Wieder mal hat es sich nicht nur wegen des Vortrags gelohnt, nach Düsseldorf zu kommen - sondern auch wegen der Diskussionen zwischendrin und hinterher.

C++ User-Treffen in Düsseldorf am 18.12.2013

2 Jahre C++ User-Treffen im Chaosdorf in Düsseldorf - 2-ter Geburtstag - und wir feierten ihn mit Kuchen und einem C++ Quiz im Kreis von 15 C++ Interessierten.

Für das leibliche Wohl war diesmal gut gesorgt. Neben den immer vorhandenen Getränken des Chaosdorfs hatten diesmal - zur Feier des 2-jährigen Geburtstags - einige Teilnehmer Kuchen und Kekse mitgebracht. So konnte jeder beim C++ Quiz seine Gehirnzellen mit genügend Nährstoffen versorgen und war immer voll leistungsfähig.

Ich hatte ein C++ Quiz mit 50 Fragen vorbereitet - insgesamt 213 Folien mit Fragen, Tipps, Variationen und Antworten - aus den verschiedensten Bereichen von C++. Ein Großteil der Fragen stammte aus meinen eigenen 20 Jahren C++ Erfahrung, aber ich hatte im Vorfeld hatte auch einige interessante Fragen von anderen Teilnehmern bekommen, und mich natürlich auch der Literatur und des Internets bedient.

Ich war sehr gespannt, wie das C++ Quiz ablaufen und ankommen würde. Ich wollte absichtlich nicht, dass jeder für sich spielt und es am Ende einen Gewinner gibt - von dieser Art des Ablaufs hätten gerade Einsteiger nichts gehabt da sie wohl von vielen Fragen überfordert gewesen wären. Statt dessen sollte die Gruppe die Fragen und Lösungen diskutieren, damit jeder seinen Beitrag leisten konnte. Und das Ganze lief viel besser ab, als gedacht. Alle Fragen wurden wirklich in der Gruppe diskutiert, zum Teil sehr kontrovers, und meist war auch unter den "Profis" die Lösung nicht unumstritten - häufig blieben mehrere mögliche Lösungen stehen.

Die richtige Antwort was dann manches Mal trotz der Diskussionen noch überraschend und brachte neue Einsichten über C++ - u.a. auch dass C++ wirklich Abgründe hat. Aber das war ja auch so geplant. Und nach einigen fiesen Fallen in den ersten Fragen wurden alle etwas zurückhaltender - selbst wenn die Lösung scheinbar klar war. Manches Mal drehte sich die Antwort nur um einfache Dinge, die aber eben doch nicht selbstverständlich waren - z.B. ob sich "pure-virtual functions" implementieren lassen, und wenn ja, ob immer oder nur bei Destruktoren (es geht übrigens immer), oder ob sich auch private virtuelle Funktionen überschreiben lassen (ja, auch das geht ganz problemlos).

Nur vier Fragen liefen nicht gut. Einmal hatte ich die falsche Antwort auf den Folien stehen (und war dann selber ob der Antwort auf der Folien unsicher - hatte ich mich vertan, und gab es da doch noch eine Falle, die ich vergessen hatte?). Dann gab es eine wohl zu einfache Frage, auf die alle direkt die richtige Antwort wußten. Und zwei Fragen wurden korrekt beantwortet, da es rethorisch anders keinen Sinn machte. Aber auch dabei hatten alle Teilnehmer ihren Spaß.

Leider kann ich das C++ Quiz nicht online stellen, da ich einige Fragen geklaut habe, und ich keine Copyright Verletzung begehen möchte. Wer sein C++ Wissen trotzdem mal testen möchte, dem kann ich aber folgende Quellen nennen - die ich bei meinen Vorbereitung natürlich auch konsultiert habe, und von denen ich mich habe inspirieren lassen bzw. bei denen ich auch geklaut habe:
  • Ein nettes C++ Quiz im Internet, das recht neu ist und daher zur Zeit leider nur 37 Fragen enthält. Aber es wird beständig erweitert: http://cppquiz.org

  • Ein C++ Quiz von der "ACCU 2012": http://www.pvv.org/~oma/PubQuiz_ACCU_Apr2012.pdf. Ich fand dieses Quiz zwar nicht so besonders, da es zuviele Fragen mit unspezifiziertem Verhalten enthält und der Fragesteller in seinen Lösungen darauf nicht eingeht - und auch nur fragt, was sein Compiler auf seiner Plattform ausgibt. Eine - gerade für C++ - sehr fragwürdige Fragestellung.

  • Ein sehr nettes und witziges PDF, das zwar primär C adressiert, aber ein tiefes Verständnis von C und C++ erwartet und dies auch propagiert: http://www.pvv.org/~oma/DeepC_slides_oct2011.pdf.

  • Buch "How not to program in C++" von "Steve Qualline", ISBN 978-1886411951.

  • Buch "Modern C++ FAQS" von "Boris Yablonsky", ISBN 978-1491235010.

C++ User-Treffen in Düsseldorf am 20.11.2013

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf wollten wir eine Video-Konferenz mit Michael Wong aufbauen - und im Gegensatz zum April-Meeting klappte es diesmal auch. 12 Interessierte in Düsseldorf konnten sich so auf neuste Infos und vielfältige Diskussionen freuen.

Wir erreichten Michael Wong in Denver, wo er sich wegen des High-Performance-Computing Standardisierungs-Treffen aufhielt. Zuerst berichtete er uns von der laufenden C++14 und C++17 Standardisierung, und den Ergebnissen vom September-Treffen in Chikago. Themen waren natürlich das leidige Trennzeichen in Zahlen-Literalen, aber z.B. auch generische Lambdas. Danach stieg er tiefer in sein Steckenpferd "Concurrency" ein, wobei diese Technical-Specifications leider nicht mehr Teil von C++14 werden. Und selbstverständlich kam in der Diskussion auch das "blockierende asnyc" auf den Tisch. In manchen Fällen (z.B. Tasks) ist dies gut, bei anderen (z.B. Wert-Berechnungen) ist dies schlecht. Wahrscheinlich wird die Lösung auf ein zweites "asnyc" hinauslaufen.

Danach erzählte Michael noch von den laufen Themen bei der HPC Standardisierung. Hier wird aktuell versucht Cilk und OpenMP miteinander zu verbinden. Es klingt verlockend, wenn das einfache Programmier-Modell von OpenMP auf GPU's oder andere Prozessoren angewendet werden könnte. Bis dahin ist aber noch viel Arbeit zu leisten - z.B. ein gemeinsames Memory-Modell. Ob das alles dann mal auch in den C++ Standard einfließt, steht aber noch in den Sternen.

Nach der Video-Konferenz rekapitulierten wir nochmal die Meeting C++ 2013, und Jens schaute ein bisschen nach vorne auf die "Meeting C++ 2014". Während ein Teil der Anwesenden sich dann auf den Weg nach Hause machte, blieb ein kleines Trüppchen Unverzagter übrig - und begann eine Diskussion über Code-Dojos. Frank Birbacher erzählte ein bisschen von seinen Erfahrungen mit und den Variationen von Code-Dojos. Und damit die Diskussion nicht so theoretisch blieb, surften wir gemeinsam zu www.cyper-doyo.com und begannen spontan mit 7 Entwicklern ein Code-Dojo. Das war ein spannendes und auch spaßiges Unterfangen - und man sammelte dabei schnell mehr Eindrücke als bei der vorherigen Diskussion - vielleicht war es das Highlight des Abends. Leider war es irgendwann einfach zu spät, und so mussten wir den Code-Dojo abbrechen und den Abend beenden.

C++ User-Treffen in Düsseldorf am 16.10.2013

Das Thema beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren Exceptions und Exception-Handling in C++. Bei diesem Thema stand schon vorher fest: es wird einen Vortrag mit vielen auch emotionalen Diskussionen geben - und so kam es dann auch. 19 C++ Entwickler waren da, und nicht jeder war ein Befürworter von Exceptions...

Nach der immer vorhandenen Motivation für Exceptions stellt Sven Johannsen zuerst kurz die Grundlagen von Exceptions in C++ (Folien des Vortrags) vor und ging dann auf speziellere Themen ein: z.B. Exceptions an Schnittstellen zu anderen Sprachen, zu Plugins oder zu Betriebssystem-Funktionen, Exception-Handling in GUI Bibliotheken wie Qt oder MFC. Danach drehte sich alles um Idioms und Pattern im C++ Exceptions-Umfeld, gutem und schlechtem Exception-Code und den Vergleich zu Error-Codes.

Während die Grundlagen von Exceptions schnell und ohne ernsthafte Diskussionen über die Bühne gingen, wurde es danach emotionaler. Wann nutzt man Exceptions, und wann doch lieber lokale Fehler-Behandlung mit If's oder Fehler-Codes? Welcher Code ist wann lesbarer, wartbarer, erweiterbarer, robuster oder schneller? Die Meinungen waren durchaus kontrovers und jeder konnte gute Beispiele für seine Sicht bringen.

Diesmal war vielleicht gar nicht der gute Vortrag das Gewinn-Bringenste am Abend, sondern die Diskussionen. Wieder einmal zeigte sich, dass Fehler-Handling - egal, ob mit oder ohne Exceptions - nicht trivial ist und je nach Programm-Typ und Stil auch nicht immer die gleichen Lösungen greifen oder zu präferieren sind. Und selbst wenn der Abend keine einstimmige Meinung bei allen Beteiligten erzeugte - so konnte doch sicher jeder neue Ansichten und Einsichten mit nach Hause nehmen.

C++ User-Treffen in Düsseldorf am 18.09.2013

Das Thema beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren wieder "Idiome in C++". Am 17.07.2013 war dieses Thema schon mal im C++ User-Meeting behandelt worden - aber nach etwas über 2 Stunden und rund 130 Folien war an dem Abend die Luft raus gewesen. Nur das Thema war noch nicht erschöpfend abgehandelt und so war klar - ein zweiter Vortrag steht demnächst an. Heute - 2 Monate später - war es soweit.

Immerhin 12 C++ Entwickler waren gekommen, um weitere C++ Idioms kennen und verstehen zu lernen. Detlef Wilkening nutzte die Gelegenheit, und erinnerte zuerst an einige Idiome des letzten Vortrags und stellt mögliche Variationen und Verbesserungen vor, die vor 2 Monaten in der Diskussion nach dem Vortrag aufgetaucht waren. Danach ging es direkt weiter mit neuen Idioms: zuerst wurde der Barton-Nackman Trick und seine Abgrenzung zum CTRP erklärt, dann folgten "Construct On First Use" und "Nifty Counter". Die "Polymorphen Exceptions" waren dann besonders interessant, da sie sich in C++11 mit "function" und "Lambdas" viel einfacher umsetzen lassen als in C++03. Auch "Type Generator", "Traits" und "Int-To-Type" waren interessante und viel diskutierte Idioms. Den Abschluß machten dann "Policies" in Form von "Policy-Funktionen" und "Policy-Klassen".

Wieder war es ein spannender und interessanter Abend, der sich für alle Beteiligten gelohnt hat.

Hinweis: einen Großteil der vorgestellten Idioms findet man z.B. im englischen Wiki-Book "More C++ Idioms".

C++ User-Treffen in Düsseldorf am 21.08.2013

Das Thema beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf war die App-Programmierung für "Blackberry 10" mit Qt. Ich konnte diesmal leider nicht anwesend sein, und so kann ich auch nichts berichten. Nächstes Mal bin ich aber wieder dabei...

C++ User-Treffen in Düsseldorf am 17.07.2013

Das Thema beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf waren "Idiome in C++". Ein Thema, das in jeder Programmiersprache wichtig ist, und sowohl dem Einsteiger als auch dem Experten wichtige Hilfen bietet. 16 Programmierer sahen die Relevanz wohl ähnlich und waren dem Ruf der "C++ Idiome" bis nach Düsseldorf gefolgt.

Detlef Wilkening began seine Reise durch die "Idiome in C++" bei den großen 3: "RAII", "Copy&Swap" und "Pimpl". Diese 3 sollte wirklich jeder C++ Programmierer kennen, da sie extrem elementar sind. Ohne "RAII", das sich z.B. im Smart-Pointern, Guards, oder Lock-Klassen manifestiert, wäre in C++ wohl kein eleganter, einfacher und exception-sicherer Code möglich. "Copy&Swap", das sehr einfache (2 Zeilen lange) Kopier-Zuweisungs-Operatoren ermöglicht, die dabei aber trotzdem funktionieren und selbst-zuweisungs- und exception-sicher sind. Und "Pimpl", das es als eine Art Compiler-Firewall ermöglicht, die Compile-Abhängigkeiten zu verringern und damit die Compile-Zeiten klein zu halten.

Nach den großen 3 kamen viele kleinere Idioms an die Reihe, die aber nicht weniger wichtig für eleganten und sicheren Code sind. So gab es einige Idioms im Umfeld von Enums, wie z.B. "Scoped-Enums" oder "Type-Safe-Enums". Danach ging es um "Make-Funktionen", wie man sie u.a. durch "make_pair" oder "make_shared" aus Boost oder dem Standard kennt - aber hierbei wurde auch die Typ-Deduktion durch Funktins-Template oder das Binden von temporären Objekten an Referenzen besprochen. Viele Idiome drehten sich um Klassen und Vererbung, wie z.B. "Named-Parameter", "Base-from-Member", oder "NVI". Am Schluß wurden noch "virtuelle Kopier-Konstruktoren" besprochen, und der Quelltext zeigt eine mögliche Umsetzung unter Nutzung der Idiome "RAII", "NVI", "Virtual-Friend-Function" und "Make-Funktion". Wie auch Design-Pattern stehen Idiome eben selten allein, sondern bedingen und unterstützen sich oft gegenseitig.

Bei fast jedem Idiom entwickelten sich Diskussionen über Einsatzgebiete und Variationen der Idiome, und wohl jeder Anwesende konnte neue Aspekte der Idiome kennen lernen. Unterm Strich war es wieder mal ein sehr gelungener C++ Abend.

Einen Großteil der vorgestellten Idiome findet man z.B. im englischen Wiki-Book "More C++ Idioms" beschrieben. Das "NVI" Idiom wird z.B. ausführlich in meinem Artikel "Virtuelle Funktionen sollten in C++ niemals public sein" vorgestellt.

C++ User-Treffen in Düsseldorf am 19.06.2013

Das Thema beim C++ User-Treffen im Chaosdorf in Düsseldorf war "Qt5" im allgemeinen, und das "Multimedia-Framework von Qt5" im speziellen. 14 C++ Programmierer waren gekommen, um diesem Vortrag von Jens Weller zu lauschen und sich über die Multimedia-Fähigkeiten von Qt5 zu informieren.

Da nur rund die Hälfte der anwesenden Entwickler schon mal mit Qt gearbeitet hatten, gab Jens Weller zuerst einmal einen kurzen Überblick über Qt5 und seine Module. Danach stellte er die wichtigsten Elemente und Konzepte vor, wie z.B. "QObject" als gemeinsame Basisklasse alle Qt-Objekte, oder auch den "Signal-Slot-Mechanismus" von Qt5.

Danach ging es mehr ans Eingemachte - das Multimedia-Framework von Qt5 wurde Thema. Statt hier die einzelnen Bestandteile, Klassen und Funktionen aufzuzählen führte Jens Weller pragmatisch mit fertigem Source-Code in das Thema ein. Er hatte ein kleines GUI-Programm geschrieben, das die Kameras und Mikrofone des jeweiligen Rechners ansteuern und damit Videos aufzeichnen und abspielen konnte. Statt theoretischen Abhandlungen ging es so direkt in den Code, und jeder konnte sehen, wie man in und mit Qt programmiert. Lebhafte Diskussionen und Fragen zu den einzelnen Klassen und Funktionen begleiteten die Code-Demo. Und so hatte hinterher jeder nicht nur das Programm verstanden, sondern auch eine Menge über Qt5 und die Multimedia-Thematik gelernt.

C++ User-Treffen in Düsseldorf am 15.05.2013

Beim diesmaligen C++ User-Treffen im Chaosdorf in Düsseldorf hielt Frank Birbacher einen Vortrag über "Shared Memory mit Boost". Dieser Vortrag war quasi der Anschlussvortrag zu seinem Vortrag über Allokatoren im März.

Leider konnte ich diesmal nicht persönlich anwesend sein, aber rund 15 interessierte C++ Programmierer sollen dagewesen sein. Wie mir berichtet wurde (Danke an Sven Johannsen für seinen Bericht), hat Frank Birbacher erstmal Allokatoren und die Neuigkeiten rund um Allokatoren in C++11 wiederholt, um dann auf Shared Memory im Allgemeinen und Boost.Interprocess im Speziellen einzugehen. Detail-Themen waren Zugriff auf benannte Shared Memorys Objekte, und die Verwaltung über globale bzw. process-übergreifende Namen. Danach ging es um die "offset_ptr" Pointer-Klasse, mit der der Zugriff basierend auf einer Basis-Adresse möglich ist - dies ist notwendig, da der Shared-Memory bei jedem Process an eine anderen Adresse eingeblendet wird. Weiter ging es mit der Erzeugung von C++ Objekten im Shared-Memory, der Benutzung des Allocatoren aus Boost.Interprocess im Zusammenhang mit angepassten Containern (das Beispiel soll gezeigt haben, wieso es wichtig in C++11 ist, dass die Allocatoren einen Status bekommen haben). Zum Schluß ging es noch um geschachtelte Zugriffe am Beispiel einer Liste von Maps von Strings, die bei der alle Objekte und Unterobjekte im SharedMemory abgelegt wurden - hierbei wurden die Objekte und Unterobjekte automatisch dank der passenden Allocatorenim im Shared-Memory abgelegt.

Unterm Strich scheine ich wirklich viel verpaßt zu haben - aber man kann ja nicht jedes Mal dabei sein. Ich hoffe aber, Frank Birbacher stellt den Vortrag auch noch im Internet zum Nachlesen zur Verfügung.

C++ User-Treffen in Düsseldorf am 17.04.2013

Diese Woche bescherte uns ein C++ User-Treffen im Chaosdorf in Düsseldorf (15 Interessierte waren da), und ein C++ Standardisierungs-Treffen in Bristol. Wir wollten uns live per Video-Konferenz von Düsseldorf aus mit Michael Wong in Bristol verbinden, und von ihm mehr über die aktuellen Themen und Beschlüsse des Standardisierungs-Treffens hören. Danach sollte es in Bristol einen Vortrag über "Concepts Light" geben, den wir auch live verfolgen wollten. So die Planung...

Die Konferenz startete pünktlich, und auf Seite von Bristol waren Michael Wong, Peter Gottschling und Frank Birbacher (aus Aachen!) zum Video-Chat hinzugeschaltet. Alle drei hatten viel zu erzählen - aber leider kam auf unserer Seite wenig davon an. Die Übertragungs-Qualität war einfach nur schlecht. Nach der Deaktivierung des Videos wurde der Ton zwar etwas besser, aber immer noch nicht wirklich verständlich. Einige Versuche später beendeten wir den Video-Chat - es hatte keinen Sinn. Auch der Versuch sich den Vortrag über "Concepts Light" mit anzuschauen, wurde aus den gleichen Gründen bald beendet. Schade, aber an diesem Abend machte uns die Technik einen Strich durch die Rechnung.

Trotzdem kamen einige Informationen bei uns an. In erster Linie war es die Erkenntnis, dass C++14 wahrscheinlich keine großen Neuigkeiten enthalten wird, sondern diese erst in C++17 enthalten sein werden. So wird z.B. die File-System Library wohl nicht Teil von C++14 sein, sondern sich nur in einem TS für C++17 wiederfinden. Hoffen wir, dass die Compiler-Bauer die TS trotzdem schon vorzeitig umsetzen.

Nachdem das Thema "Video-Chat" abgehakt war, rollten wir die Themen "Bristol" und "C++14" anders auf: Jens Weller stellte 98 Proposals für C++14 und C++17 vor, die Thema in Bristol sein sollten. Er bezog sich hierbei auf seine Blogeinträge der letzten Wochen unter Meeting C++: Aufgrund der Menge an Proposals und des späten Starts wurde es ein langer Abend. Es war fast 23:00 Uhr, als wir die Proposals "abgearbeitet" hatten - aber es hatte zwischendurch auch manche längere Diskussion gegeben. Selbst wenn die Themen für unsere tägliche Arbeit noch nicht relevant sind - es war doch interessant zu sehen, wohin sich C++ entwickelt.

Nachträge:
  • 08.05.2013: Auch Jens Weller hat den Abend in einem Blog-Eintrag auf Meeting C++ festgehalten.
  • 08.05.2013: Auf der ISO C++ Web-Seite wurde direkt am Wochenende nach dem C++ Standardisierungs-Treffen von Herb Sutter eine Zusammenfassung der Ergebnisse von Bristol veröffentlicht.
  • 08.05.2013: Mittlerweile hat auch Michael Wong in seinem Blog in immerhin 3 Teilen seine Sicht auf das ISO C++ Meeting in Bristol dargstellt:
  • 08.05.2013: Und auch Anthony Williams war fleissig, und hat in seinem Blog einen kurzen Bericht über das ISO C++ Meeting in Bristol verfaßt - natürlich mit Focus auf den Concurrency-Group Themen (SG1).

C++ User-Treffen in Düsseldorf am 20.03.2013

Diesmal hatte ich mich besonders auf das C++ User-Treffen gefreut: das Thema "Allokatoren" versprach viel Neues für mich, denn "Allokatoren" gehören zu den wenigen Themen in C++, mit denen ich mich noch nie beschäftigt hatte. 15 weiteren Programmierern erging es vielleicht ähnlich, denn sie waren wie ich zum C++ User-Treffen im Chaosdorf in Düsseldorf gekommen - und viele Fragen zeigten, dass das Wissen über Allokatoren vor dem Vortrag nicht besonders hoch war.

Und so war es auch ganz gut, dass Frank Birbacher erstmal die Allokatoren in C++03 vorstellte. Hier zeigte sich, dass sie in C++03 nicht trivial zu implementieren waren, und trotzdem noch eine Menge Probleme hatten. Der Standard von 2003 definierte einfach zuviele Dinge nicht sauber (z.B. Kopier- oder Move-Semantik), und andere Dinge zu eingeschränkt (z.B. dürfen Allokatoren in C++03 keinen Zustand haben).

Danach wandte sich Frank den Allokatoren in C++11 zu. Hier hatte sich einiges getan: die Definition von Allokatoren ist stark verbessert und verallgemeinert worden - und gleichzeitig sind sie viel einfacher zu implementieren. Das sollte natürlich nicht nur theoretisch im Raum stehen, und so hatte Frank auch ein einfachen Arena-Allokator implementiert. In einem Anwendungsfall, bei dem der Arena-Allokator theoretisch Vorteile versprach, hatte er dann Performance, Speicherverbrauch und einige andere Messgrößen für den Standard-Allokator und den Arena-Allokator gemessen. Fazit: bei ungefähr gleichem Speicherbedarf war die Messung mit Arena-Allokator ungefähr 4 x so schnell - der Einsatz lohnt also.

Ein Handikap gab es noch zum Schluß: ein C++11 Allokator läßt sich aktuell leider nur mit dem CLang 3.2 implementieren - sowohl der aktuelle GCC 4.7 als auch das aktuelle Microsoft Visual Studio 2012 sind hier noch nicht weit genug. Aber wir hoffen natürlich alle, dass sich das schnell ändert.

Unterm Strich wieder mal ein mehr als nur lohnenswerter Abend in Düsseldorf.

C++ User-Treffen in Düsseldorf am 20.02.2013

Und wieder waren 19 Interessierte zum C++ User-Treffen im Chaosdorf in Düsseldorf gekommen, füllten den Raum und freuten sich auf einen Abend mit "Generischer Programmierung in C++".

Guntram Berti stieg langsam in das Thema ein, und zeigte uns zuerst einen einfachen Algorithmus für die Summation von Double-Werten in einem Container. Diesen Algorithmus verallgemeinerte er im Laufe des Abends immer mehr, bis am Schluß eine ganz und gar generische Version übrig blieb. Auf dem Weg dahin zeigte sich manches Problem, für das es nicht immer eine beste Lösung gab. Ein Beispiel dafür war die Typisierung und Initialisierung der Ergebnis-Variable - hierfür gab es mehrere Möglichkeiten, und jede hatte ihre Vor- und Nachteile.

Überhaupt - der ein oder andere Experte im Raum hatte sich vorher gefragt, ob das Thema noch genug Neues für einen Vortrag bot - immerhin ist generische Programmierung seit der STL in C++ doch relativ bekannt. Aber gerade die Ecken und Ösen bei der Verallgemeinerung der Algorithmen boten Stoff für manche Nachfrage und Diskussion, und so kam keiner zu kurz - Anfänger nicht und Experten auch nicht. Guntram Berti hatte immer wieder interessante Aspekte und Varianten der generischen Programmierung in seinem Vortrag zu bieten - und so kann man als Fazit wiedermal sagen: Alle, die nicht da waren, haben was verpaßt.

C++ User-Treffen in Düsseldorf am 16.01.2013

Diesmal war es relativ voll beim C++ User-Treffen im Chaosdorf in Düsseldorf. Immerhin 19 Leute waren gekommen - und damit war das Chaosdorf schon gut ausgelastet. Aber das Thema hatte die Aufmerksamkeit auch wirklich verdient: "Smart-Pointer".

Die Nutzung von RAII und damit vor allem von Smart-Pointern gehört zu den wichtigsten Regeln in C++. Einfach jeder C++ Programmierer sollte sich hier zumindest rudimentär auskennen. Selbst C++ Einsteigern sollten Smart-Pointer ein Begriff sein - und sobald man explizit mit dynamischer Speicherverwaltung arbeitet müssen Smart-Pointer einfach zum Handwerkszeug gehören. C++ Code mit "new"s und ohne Smart-Pointer darf es nicht geben - explizite "delete"s haben in einem C++ Programm nichts zu suchen.

Sven Johannsen führte die Anwesenden in einem fast 2 stündigen Vortrag in die Welt der C++ Smart-Pointer ein. Nach dem Einstieg in Smart-Pointer, ihren grundsätzlichen Besitz-Strategien und Verwendungen, ging es tiefer in die Details. So wurden neben dem mittlerweile deprecatiten C++03 "auto_ptr" und dem sehr einfachen Boost "scoped_ptr" auch die C++11 Smart-Pointer "unique_ptr", "shared_ptr" und "weak_ptr" detailliert vorgestellt. Weiter ging es mit wichtigen Utilities wie z.B. "make_shared" oder "enable_shared_from_this" über Fragen zur Verwaltung dynamischer Arrays bis hin zu Smart-Pointern für Windows COM-Objekte und Smart-Pointern in Qt.

Besonders lebte der Abend wieder von den sehr tiefen Fragen der Anwesenden, unter denen sich mancher C++ Experte befand. Diese Fragen führten zu Diskussionen z.B. über die Gründe, warum der "unique_ptr" seinen Deleter als Template-Argument enthält, der "shared_ptr" dagegen als Konstruktor-Argument bekommt. Oder über den Grund für die Element-Funktion "release" in der Schnittstelle von "auto_ptr" und "unique_ptr".

Insgesamt ein rundum gelungener Überblick und ein interessanter Abend - und wohl alle konnten was Neues mit nach Hause nehmen.

C++ User-Treffen in Düsseldorf am 19.12.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf waren ein Rückblick auf das C++ Jahr 2012 und die C++11 R-Value-Referenzen die Themen des Abends. Leider waren nur 7 Interessierte gekommen - lag es am Wetter, an den Staus im Großraum Düsseldorf, am DFB-Pokal Viertelfinale, am nahen Weihnachtsfest oder auch am C++11 Thema, das sicher keine Einstiegskost war? Wir wissen es nicht - aber alle, die nicht da waren, haben was verpaßt.

Der Abend began mit einem Rückblick von Jens Weller auf das C++ Jahr 2012 - eröffnet mit einem Abriss unserer C++ User-Treffen in Düsseldorf. Danach wandte er sich den anderen C++ Highlights des Jahres zu: zum einen den Entwicklungen in der C++ Standardisierung und bei den aktuellen C++ Compilern, aber auch den C++ Konferenzen in 2012. Hierbei nahm natürlich die "Meeting C++" einen relativ großen Raum ein, da viele Anwesende auf der Meeting C++ selber aktiv waren oder sie zumindest besucht hatten.

Danach übernahm Detlef Wilkening den Abend und stellte vor wo in C++ überflüssige Kopien zu Performance-Problemen werden können, und wie man diese in C++11 vermeidet. Dazu wurde zuerst im Detail die Unterscheidung von L- und R-Values vorgestellt, und dann die in C++11 neuen R-Value Referenzen eingeführt. Weiter ging es mit den Unterschieden zwischen L- und R-Value-Referenzen (auch const) beim Initialisieren und Überladen. Nach diesen Grundlagen war der Weg geebnet zum Verständnis der Move-Semantik, und der Implementierung in eigenen Klassen mit Hilfe von Move-Konstruktoren und Move-Zuweisungs-Operatoren. Der nächste Schritt waren die Konsequenzen für eigene Funktionen und Klassen mit Move-Semantik Parametern bzw. Attributen. Den Abschluß bildete der nicht ganz triviale Ausflug zum Perfect-Forwarding mit den Universal-Referenzen in Funktions-Templates und die Nutzung von "std::forward<T>". Keine wirklich einfach Kost - und so schloß sich noch manche Frage und Diskussion an den Vortrag an.

C++ User-Treffen in Düsseldorf am 21.11.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf stand die kommende Entwicklung von C++ im Mittelpunkt. Und obwohl sich C++11 noch nicht flächend-deckend durchgesetzt hat und wir alle noch auf vollständig standard-konforme Compiler warten, war das Thema für 17 Programmierer genug Grund zu kommen.

Den Einstieg übernahm Jens Weller, und er gab zuerst einen Überblick über die aktuelle Entwicklung von C++ nach dem letzten Standardisierung-Treffen in Portland mit einem Ausblick auf C++14 und C++17. Danach stellte er grob einzelne Themen vor, die im Augenblick in der C++ Standardisierung diskutiert werden und wohl in die nächsten Standards einfließen werden. Hierbei bezog er sich vor allem auf das Video von Herb Sutter über die Zukunft von C++ und auf den Blog-Eintrag von Michael Wong, aber auch auf die Mailing-Liste der Standardisierungs-Gruppe mit allen aktuellen Proposals.

Den zweiten Teil übernahm Detlef Wilkening - er hatte sich als konkretes Thema "Transactional Language Constructs for C++" (n3341) ausgesucht. Transaktionaler Speicher verspricht ein viel einfacheres und leistungsfähigeres Multi-Threading Programmiermodel als die typische aktuelle MT Entwicklung mit Locks, Mutexen und Atomics. Und in Verbindung mit Hardware Unterstützung auch eine bessere Performance - reine Software-Lösungen werden hier wohl hinterherhinken. Vor allem sind Funktionen, Module oder Bibliotheken, die auf transaktionalem Speicher aufbauen, zusammensetzbar - daher es können problemlos aus kleineren Teilen größere Programme zusammengesetzt werden. Herkömmliche Mechanismen wie eben z.B. Locks oder Mutexe sind eben nicht "composable" - und ihr Einsatz in Bausteinen führt häufig zu Fehlern, schlechter Performance und Deadlocks. Detlef Wilkening stellte erst detailliert die obigen Probleme dar - und zeigte dann wie transaktionaler Speicher in C++ funktionieren könnte und u.a. die obigen Probleme löst. Hoffen wir, daß es dieses interessante und vielversprechende Sprachfeature in den Standard C++17 schafft.

Beide Vorträge führten zwischendurch immer wieder zu vielen Fragen und Diskussionen, und auch hinterher gab es noch manches C++ Thema zu besprechen - auch ganz abseits der Zukunft C++14 und C++17. Der Abend hatte sich mal wieder für alle Beteiligten gelohnt.

C++ User-Treffen in Düsseldorf am 17.10.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf stellte Jens Weller zuerst kurz die C++ GUI Entwicklung mit Qt & QML vor, und wechselte dann zum Thema "Mobile Apps" mit Qt & QML. Jens hatte - sicher auch motiviert durch das letzte C++ User-Treffen - eine App für die Messung von magnetischen Feldern auf BlackBerry 10 von RIM portiert. Natürlich hatte er dabei manche negative und positive Erfahrung gemacht, und ließ uns an seinen Erkenntnissen teilhaben. Da auch einige andere der anwesenden 12 C++ Entwickler schon für mobile Plattformen und im letzten Monat speziell für BlackBerry 10 entwickelt hatten, konnten sie manches bestätigen und weiteres Wissen ergänzen.

Der Höhepunkt des Abends hatte dann aber gar nichts mit mobilen Endgeräten zu tun. Per Skype schaltete sich Michael Wong live vom Standardisierungs-Treffen aus Portland in Oregon während der Mittagspause unserem User-Treffen zu, und erzählte von den aktuellen Themen in der C++ Standardisierung. Er berichtete u.a., daß versucht wird für 2014 ein TC Zwischen-Standard C++14 umzusetzen, der aus Fehler-Korrekturen und kleinen Ergänzungen wie z.B. die freien Funktionen "cbegin" und "cend" bestehen soll. Der übernächste C++ Standard mit vielen Erweiterung soll dann 2017 kommen. Konkrete Themen auf diesem Standardisierungs- Treffen sind z.B. eine automatische Return-Typ-Deduktion für Funktionen, wie sie im aktuellen C++11 Standard für Lambda-Ausdrücke vorhanden ist, viele Multi-Threading Erweiterungen in der Bibliothek, Erweiterungen der Lambda-Ausdrücke, Datei-System-Handling, und vieles mehr. Am Schluß nahm sich Michael Wong noch Zeit, Fragen von uns bzgl. C++ und der Standardisierung zu beantworten. Ein spannender Abschluß eines interessanten Abends.

C++ User-Treffen in Düsseldorf am 19.09.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf war Kamel Lajili von RIM ("Research In Motion") zu Besuch und stellte den Entwicklungs-Stack von RIM für die BlackBerry 10 Entwicklung vor. Zentraler Bestandteil - zumindest aus Sicht der C++ Programmierer - ist das neue C++ Framework Cascades, das auf Qt & QML basiert und native Applikation ermöglicht. Als Entwicklungs-Umgebung wird sowohl Eclipse als auch das Microsoft Visual Studio mit Plugins unterstützt - für jeden Entwickler sollte also was dabei sein. 13 C++ Programmierer verfolgten den Vortrag mit Interesse und vielen Zwischenfragen - und hinterher ergaben sich eine Menge Diskussionen über RIM, BlackBerry 10 und Cascades im speziellen, aber auch allgemein über die Entwicklung mobiler Applikationen in C++ für alle mobile Plattformen. Für meinen persönlichen Geschmack ging es diesen Abend zuwenig um C++ selber, und zuviel um Qt, QML und Apps - aber das haben andere auch anders gesehen.

C++ User-Treffen in Düsseldorf am 15.08.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf war das Thema von Jens Weller die Library LibTooling, welche Zugriff auf die Clang API bietet. Leider konnte ich selber nicht anwesend sein, und musste so auf dieses super interessant klingende Thema verzichten. Aber zum Glück hat Jens Weller ein Blog Beitrag veröffentlicht, der dem Inhalt der Vortrags entspricht.

C++ User-Treffen in Düsseldorf am 18.07.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf war das Thema des Vortrags von Detlef Wilkening die neuen C++11 Lambda-Ausdrücke - leider gibt es den Vortrag noch nicht online. 12 Programmierer wollten einen Blick auf einen Teil des neuen aktuellen C++ werfen, und ließen sich auf eine Tour durch und um Lambdas, Closures, Captures, Introducers und Funktions-Objekte ein. Nach vielen Feinheiten von Lambdas gab es zum Schluß noch zwei beispielhafte Anwendungen aus der funktionalen Programmierung, u.a. die Komposition von Funktionen.

C++ User-Treffen in Düsseldorf am 20.06.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf berichtete Jens Weller von der ADC++ und der C++Now! (ehemals BoostCon) vom Mai bzw. Juni dieses Jahres. 8 Interessierte waren gekommen, um zumindest sekundäre Informationen über C++ von beiden Konferenzen abgreifen zu können.

Direkte Informationen zu C++ gab es diesmal nicht - aber damit hatte wohl auch keiner der Anwesenden gerechnet. Statt dessen berichtete Jens Weller allgemein von den aktuellen Themen und einzelnen Highlights der Konferenzen. Aber nicht nur C++ war diesmal das Thema - Jens nutzte die Gelegenheit auch zu einem Blick über die Programmiersprache hinweg und und zeigte z.B. Fotos aus Bayern und Aspen und schilderte die Atmosphäre der Konferenzen. Selbst wenn man also nichts Neues über C++ selber lernen konnte, so waren die Konferenz-Eindrücke den Weg nach Düsseldorf allemal wert.

Wer - wie wohl die Meisten von uns - nicht das Glück hatte, selber die Konferenzen besuchen zu können, findet zum Glück weitere Informationen im Internet: Ein weiteres Thema an diesem Abend war der aktuelle Planungs-Status einer C++ Konferenz in Düsseldorf bzw. auf der anderen Rheinseite in Neuss. Am 9. und 10. November 2012 soll dort die "Meeting C++" (http://www.meetingcpp.de) stattfinden, und Jens Weller informierte die Anwesenden über Ziele, Pläne und Status dieser Konferenz.

C++ User-Treffen in Düsseldorf am 16.05.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf war das Thema des Vortrags von Detlef Wilkening die Operator-Überladung in C++ von A bis (fast) Z. Immerhin 8 Entwickler waren an diesem doch eher langweilig erscheinenden Thema interessiert und fanden ihren Weg ins Chaosdorf.

Das Thema war dann aber doch interessanter und vielfältiger, als mancher erwartet hatte. Hinter Operator-Überladung verbirgt sich für C++ eben mehr, als nur ein syntaktisches Schmankerl für mathematische Klassen. Und so wurde es nach den unvermeidlichen Grundlagen schnell vielschichtiger, und manche Operator-Besonderheit barg neue und interessante Informationen über andere Bereiche von C++. Den Abschluß bildete dann noch ein Exkurs in die Boost.Operator Bibliothek, die das Schreiben von eigenen Operator-Funktionen vereinfachen kann.

Obwohl der Vortrag gegenüber dem Internet-Beitrag stark gekürzt war, dauerte er - auch aufgrund mancher Diskussion - dann doch wieder mehr als 2 Stunden. Und so war das Treffen hinterher leider direkt zu Ende.

C++ User-Treffen in Düsseldorf am 18.04.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf war das Thema des Vortrags von Detlef Wilkening mögliche Performance-Optimierungen in C++. Ein Thema, das wohl für viele ein Grund für ihre C++ Vorliebe ist - und so kamen 18 interessierte Entwickler.

Detlef Wilkening stellte viele kleinere und größere Änderungen an C++ Programmen vor, und beschrieb den Grund für die möglichen Performance-Verbesserungen. Neben der Theorie hatte er die meisten Beispiele mit verschiedenen Compilern übersetzt und auf verschiedenen Plattformen ausprobiert - daher wurde die Theorie immer mit der Praxis konfrontiert und erwies sich manches Mal als korrekt. Interessant waren natürlich auch die vorhandenen Diskrepanzen zwischen Theorie und Praxis und die wahrscheinlichen Gründe für sie. Viele Themen und Beispiele wurden zwischendurch von den Anwesenden diskutiert und mit eigenen Erfahrungen angereichert.

Auch diesmal sprengte der Vortrag bei weitem die 2 Stunden Grenze - gerade auch aufgrund der zahlreichen Diskussionen während des Vortrags - und so löste sich das User-Treffen hinterher relativ schnell auf. Aber wohl jeder nahm Ideen und Anregungen für Performance-Optimierungen in C++ mit - und vor allem das Wissen, das man Messen, messen und messen muss.

C++ User-Treffen in Düsseldorf am 21.03.2012

Beim diesmaligen C++ User-Treffen im Chaosdorf Düsseldorf war das Thema des Vortrags von Jens Weller eine Einstieg in die STL. Trotz dieses für C++ wichtigen und interessanten Themas fanden nur 6 Personen den Weg ins Chaosdorf. Vielleicht lag es aber auch einfach nur am Streik (der öffentliche Nahverkehr war lahm gelegt), oder am nur 40 km entfernt parallel statt findenen DFB-Halbfinale zwischen Borussia Mönchengladbach und Bayern München, das auch im Fernsehen übertragen wurde (Bayern München gewann nach Elfmeterschiessen mit 2:4, nach der Verlängerung stand es noch 0:0). Aber ein echter C++ Nerd kann doch nicht auch Fußball-Fan sein, oder?

Wie dem auch sei - die Anwesenden hörten einen aufschlussreichen Vortrag über Streams, Container und Algorithmen.

Da der Vortrag diesmal etwas kürzer war, blieb hinterher viel Raum und Zeit für Diskussionen, was auch stark genutzt wurde. Und so tauschten sich die Teilnehmer noch über Container-Implementierungen, Templates, Funktions-Zeiger, generisches Wrappen von Funktions-Aufrufen und das Multi-Threading Memory-Modell von C++ aus.

C++ User-Treffen in Düsseldorf am 22.02.2012

Beim diesmaligen User C++ Treffen im Chaosdorf Düsseldorf war das Thema des Vortrags von Detlef Wilkening eine Einführung in die C++ Bibliothek Boost. 14 Interessierte lockte dieses Thema trotz Karnevals nach Düsseldorf ins Chaosdorf.

Neben allgemeinen Erklärungen zu Boost, Informationen zur Einbindung von Boost in die C++ Standardisierung und einem Ausblick in die Zukunft von Boost wurden 13 der aktuell 111 Boost Bibliotheken (Boost 1.48.0) mit Beispielen etwas detaillierter vorgestellt. Unterm Strich blieben natürlich viele Fragen zu konkreten Boost-Bibliotheken offen - trotzdem wurde jedem Teilnehmer Lust gemacht sich vermehrt mit Boost zu beschäftigen und mehr einzusetzen.

Nach dem Vortrag entwickelten sich noch einige interessante Diskussion rund um C++ und Boost.

C++ User-Treffen in Düsseldorf am 18.01.2012

Für das diesmalige C++ User-Treffen im Chaosdorf Düsseldorf war ein Vortrag von Jens Weller zum Thema Einstieg in C++ angekündigt. Dieses Thema lockte neben einigen fortgeschrittenen C++ Programmierern viele Einsteiger und Neulinge von C++ an - und so fanden sich 21 Interessierte im Chaosdorf ein.

In rund 2 3/4 Std. handelte Jens Weller viele Grundlagen und auch einige weiterführende Themen von C++ ab: Typen, Variablen, Kontrollstrukturen, Zeiger, Referenzen, ein paar STL Container, dynamische Speicherverwaltung, Klassen, Vererbung, Polymorphie, ... An den Fragen und Diskussionen während des Vortrags konnte man gut erkennen, dass ein sehr gemischtes Publikum vorhanden war - und letzlich konnte wohl jeder etwas für sich mitnehmen.

Aufgrund der fortgeschrittenen Zeit gab es hinterher keine Diskussionen mehr.

C++ User-Treffen in Düsseldorf am 14.12.2011

Jens Weller und das Chaosdorf Düsseldorf luden zum ersten C++ User-Treffen ein, und 11 Interessierte folgten diesem Aufruf.

Die C++ User-Treffen werden nun monatlich stattfinden - voraussichtlich immer am dritten Mittwoch des Monats. Ein Ziel der Treffen soll sein, dass sich C++ Programmierer austauschen und ihr C++ Netzwerk pflegen können. Im Mittelpunkt der Treffen soll entweder ein Vortrag, ein Coding-Event oder eine andere Aktion stehen, die sich aber immer um C++ dreht.

Jens Weller selber übernahm den Auftakt und hatte dafür einen Vortrag über einige Neuigkeiten des neuen C++11 Standards und Qt vorbereitet. Hinterher stellten sich die Anwesenden vor und erzählten von ihren C++ Projekten und Erfahrungen, woraus sich anregende Diskussionen entwickelten.
C++ User-Treffen: