Wilkening-Online Logo

Berichte von den C++ User-Treffen in Köln


Von Detlef Wilkening

Nächstes Treffen: Allgemeine Informationen:

C++ User-Treffen in Köln am 20.03.2018

Das diesmalige C++ User-Treffen in Köln drehte sich um die Consensus Algorithmen PAXOS und RAFT aus dem Bereich der verteilten Systeme. Immerhin 14 C++ Interessierte waren gekommen, um sich diesem doch recht theoretischen Thema zu stellen. Im Kern behandeln beide Protokolle das CAP-Theorem - wobei die Verfügbarkeit "(A availability)" zugunsten der Konsistenz "(C consistency)" geopfert wird.

Den Anfang machte Michael Wielpüetz mit dem PAXOS Protokoll. PAXOS ist ein relativ altes (1988) und sehr komplexes Protokoll - und so hatte sich Michael viel vorgenommen, uns dieses Brocken mundgerecht zu servieren. Es gelang ihm aber sehr gut, denn er hatte einige einfache Beispiele als Grafiken vorbereitet, um den konzeptionellen Ablauf zu verdeutlichen. Trotzdem gab es eine Menge Rückfragen und Diskussionen, bis alle Anwesenden das Konzept verstanden hatten - es war wirklich nicht einfach.

Kaveh Vahedipours stellt danach RAFT vor. RAFT ist viel neuer (2014) und einiges einfacher - trotzdem ist bedingt durch die eigentliche Problematik auch RAFT nicht trivial. Die Vorstellung von RAFT gelang Kaveh aber sehr gut - auch weil er auf die Visualierung der RAFT GitHub Seite zurückgreifen konnte - probiert sie mal aus, und spielt mit den Eigenschaften der Knoten (Klick auf die Knoten) rum. Nachdem wir auch diesen Algorithmus verstanden hatten, zeigte uns Kaveh noch realen Code aus der verteilten NoSQL Datenbank "ArangoDB", in der das RAFT Protokoll implementiert ist.

Insgesamt war es ein recht theorie-lastiger Abend, der aber trotzdem sehr spannend und interessant war. Gerade weil die meisten von uns wohl selten mit Consensus Algorithmen zu tun haben, gab es viel zu diskutieren. Aber alle Anwesenden hatten hinterher einiges Neues aus diesem Bereich gelernt - der Abend hat sich also sicher gelohnt.

C++ User-Treffen in Köln am 28.11.2017

Zum diesmaligen C++ User-Treffen in Köln waren 12 interessierte C++ Programmierer gekommen, um zwei Vorträge über Bemühungen zur Vereinheitlichung von Code-Checker-Formaten und die Boost Bibliotheken zu hören.

Zuerst stellte Stefan Hagen in einem Kurz-Vortrag die Bemühungen von Oasis (Advancing open standards for the information society) vor ein leistungsfähiges und einheitliches Ausgabe-Format für Code-Checker zu definieren, und dieses bei den großen Playern bekannt zu machen.

Danach habe ich einen Überblick über die Boost Bibliotheken gegeben. Nach einer wirklich kurzen Einführung in Boost habe ich dann 18 Bibliotheken detaillierter vorgestellt. Wobei "detailliert" hier relativ zu verstehen ist. Immerhin habe ich zwar über 2 1/2 Stungen vorgetragen - umgerechnet auf 18 Bibliotheken waren es aber im Schnitt nur 8 Minuten pro Bibliothek - wirklich detailliert kann man das nicht nennen.

Meine Auswahl war ganz subjektiv und war bestimmt durch die Kriterien, dass ich keine mittlerweile im Standard (C++17 ausgenommen) vorhandene Bibliothek vorstellen wollte, und ich natürlich nur Bibliotheken vorstellen wollte, die ich aus eigenen Projekten etwas kannte. So fiel meine Auswahl auf - in alphabetischer Reihenfolge: Any, BiMap, Coroutine2, Date-Time, Fiber, Flyweight, Hana, Multi-Index, Operator, Optional, Pointer-Container, Serialization, Signals2, Spirit, String-Algorithm, Tokenizer, UUID und Variant.

Der Vortrag gab einen Überblick über diese 18 Boost Bibliotheken, und - selbst wenn natürlich keine Details möglich waren - so lernten doch viele Anwesende neue Bibliotheken kennen und werden sie in Zukunft vielleicht auch einsetzen. Und das war genau der Sinn des Vortrags - mal schnell vorstellen, was es da alles schönes in Boost gibt.

C++ User-Treffen in Köln am 24.01.2017

Beim diesmaligen C++ User-Treffen in Köln waren 17 C++ Interessierte anwesend und bekamen zwei interessante Vorträge serviert.

Im ersten Vortrag ging es wie beim letzten Treffen um "C++ Koroutinen" - Daniel Oberhoff führte seinen Vortrag vom letzten Treffen fort. Zuerst motivierte er noch mal Koroutinen, indem er ein kleines Python Programm zeigte, das Koroutinen nutzte - Python kennt Koroutinen schon länger. Daniel wies immer wieder darauf hin, dass zur Zeit in C++ drei Proposals für Koroutinen disktuiert werden - und daher noch nicht klar ist wie die endgütige Lösung in C++20 aussehen wird. Daher zeigte er für alle drei Proposals Beispiele, und diskutierte auch die Vor- und Nachteile der vorgeschlagenen Lösungen. Im Prinzip unterschieden sie sich dadurch, dass ein Proposal einfach zu nutzen ist - dafür aber kaum Kontrolle zuläßt. Ein anderes Proposal ermöglichte die volle Kontrolle bei der Ausführung, war aber nicht einfach zu nutzen - und Proposal 3 lag dazwischen. Lassen wir uns überraschen, wie Koroutinen in C++20 aussehen werden. Die Diskussionen während des Vortrags zeigten jedenfalls, dass sie ein interessantes Thema mit vielen Anwendungen sind - aber auch nicht einfach zu verstehen.

Der zweite Vortrag von Andreas Milton Maniotis drehte sich um saubere Schnittstellen. Motiviert hatte Andreas mein Vortrag über Varianten des Builder-Idioms beim C++ User-Treffen in Düsseldorf im November 2016. Ich hatte damals mehrere Varianten vorgestellt wie man Funktionen mit vielen Parametern übersichtlicher und flexibel gestalten kann. (Mittlerweile kenne ich 3 weitere Varianten - ich muss den Vortrag wohl nochmal halten.) Alle meine Varianten (auch die Neuen) setzen voraus, dass man die Schnittstellen direkt entsprechend übersichtlich gestaltet Andreas Vortrag setzte einen anderen Schwerpunkt: Was macht man, wenn man eine Bibliothek mit schlechten Schnittstellen hat? Kann man hier die Funktionen nicht auch - ohne Veränderung der Bibliothek - entsprechend umgestalten, d.h. eine dünne Schicht darüber legen? Andreas Builder-Framework ermöglicht den Aufruf von vorhandenen Konstruktoren mit einem Builder-Ausdruck, der die korrekten Typen zur Compile-Zeit absichert und selbständig die Reihenfolge einhält. Nach der Vorstellung seines Ziels zeigte uns Andreas seinen Quelltext, der - dank Templates und TMP - nicht immer leicht zu verstehen war. Die Hauptidee war die Ableitung seiner Builder-Klasse von Wrappern aller Parameter-Typen und die Nutzung einer variadischen Member-Initialisierungs-Liste. Hierbei sortiert der Compiler selbständig die Initialisierungen in die Reihenfolge der Basis-Klassen um. Auch Andreas Vortrag löste viele Fragen und Diskussionen aus - bis alle Anwesenden die Idee und Umsetzung verstanden hatten. Ob man solch ein Builder-Framework nutzen möchte, war bei manchen Teilnehmern dann aber doch nicht ganz klar.

Nach den Vorträgen haben wir noch lange beisammen gesessen und über C++, Programmieren und vieles mehr gesprochen. Es ist am Ende wieder ein interessanter Abend gewesen - nicht nur wegen der Vorträge.

C++ User-Treffen in Köln am 22.11.2016

Beim C++ User-Treffen in Köln war ein Vortrag von Daniel Oberhoff über "C++ Koroutinen" vorgesehen. Leider konnte ich diesmal nicht dabei sein. Vielen Dank an Michael Wielpütz für den folgenden Bericht:

Mit ca. 15 Besuchern war es für Kölner Verhältnisse relativ voll. Daniel Oberhoff hat seinen Vortrag über Koroutinen gehalten. Wir hatten im Anschluss daran noch einige interessante Diskussionen. Eigentlich hätten wir gerne noch einmal Koroutinen ausprobiert um einige offene Fragen zu klären. Das ist aber leider am Compiler gescheitert. Wir haben ihn nicht dazu überreden können das Koroutinen-Tutorial von der Microsoft Webseite zu kompilieren.

C++ User-Treffen in Köln am 27.9.2016

Zum diesmaligen C++ User-Treffen in Köln waren nach der langen Sommerpause immerhin 12 C++ Programmierer gekommen. Michael Wielpütz und Thorsten Wendt hatten für den Abend ein Code-Dojo geplant, aber sie hatten im Vorfeld auch angekündigt, dass sie sich über ein oder zwei kleine Vorträge freuen würden, die vorher gerne gehalten werden könnten. 2 Teilnehmer hatten dann auch kleine 5 Minuten Vorträge dabei, und so war der allgemeine Konsenz, mit den kurzen Vorträgen zu beginnen und danach zum Code-Dojo zu wechseln. Aber der Abend sollte sich ganz anders entwickeln...

Der ersten Kurzvortrag steuerte dann Thorsten Wendt selber bei. Er drehte sich um Assertions und stellte mehr Fragen als er beantwortete - z.B. wie man sie sinnvoll einsetzt, ob sie im Release- und/oder Debug-Modus greifen sollten, ob sie das Programm hart terminieren lassen oder es sauber runterfahren oder nur eine Exception werfen sollten, oder ob sie gut sind oder nicht, uvm. Thorsten hatte seinen Vortrag absichtlich nicht als Lösung ausgelegt, sondern suchte Antworten auf seine Fragen. Er schilderte kurz den Status bzgl. Assertions in seinem aktuellen Projekt vor und stellte dann die Frage in den Raum, wie denn die Anwesenden mit Assertions umgehen, ob sie sie nutzen, wie sie einsetzen, und wie ihre Erfahrungen sind. Jeder konnte hierzu natürlich etwas betragen und quasi alle berichteten aus ihren Projekten und geizten nicht mit ihren Erfahrungen. Das Thema klang zuerst so einfach, offenbarte dann aber doch eine tiefe Komplexität, da man Assertions auf viele Arten einsetzen und nutzen kann. Der sich so entwickelnde Erfahrungsaustausch und die anschliessende Diskussion waren super interessant und spannend - da aus der direkten Praxis kommend - und nahm dann statt 5 Minuten fast 1 1/2 Stunden ein.

Auch der zweite Kurzvortrag entpuppte sich als ein echter Zeitkiller. Stephan W Schwichtenberg wollte eigentlich nur kurz seine C Netzwerk Library "neuro:pil" für Secure Messaging im Internet-of-Things vorstellen und etwas Werbung für sie machen. Es ist eine ungefähr 20 KByte große C99 Bibliothek, die neben einer zentraler Verwaltung auch Skalierbarkeit und ein dezentrales Messaging unterstützt. Da sie so klein ist, läßt sie sich problemlos auch in kleinen Embedded-Systemen nutzen - also ideal für das Internet-of-Things. Leider ist die Bibliothek noch nicht öffentlich und noch nicht Open-Source - Stephan hat aber versprochen dies in den kommenden Monaten umzusetzen. Ich werde dann hier einen entsprechenden Link veröffentlichen - zur Zeit kann ich nur mit diesem Link auf das Projekt neuro:pil dienen. Update 8.10.2016: mittlerweile gibt es eine Webseite für das Neuro:pil Projekt inkl. Link auf die Sourcen in einem Mercurial Repository.

Aber zurück zum Treffen - die Präsentation hätten wir sicher problemlos in 5 Minuten durchbekommen - aber schon die ersten Folien warfen Verständnis- und Anwendungsfragen zu "neuro:pil" auf. Uns war überhaupt nicht klar, wie die einzelnen Clients sich finden und miteinander kommunizieren, wie sie ihre Kommunikations-Partner lokalisieren, wie das Verschlüsselungs- und Authentifizierungs-Konzept arbeitet, uvm. Statt die Folien einfach hinzunehmen, wurden die genutzten Verfahren und Algorithmen in Frage gestellt, detailliert diskutiert und ausführlich erläutert - Stephan stellte sich hierbei all unseren Fragen und verzweifelte nicht (danke), war aber sicher einige Male kurz davor.

Auch dieser Vortrag dauerte dann über eine Stunde, war aber eben dadurch für alle interessant und aufschlussreich. Danach war eindeutig keine Zeit mehr für ein Code-Dojo. Statt dessen wechselte der Abend in den gemütlichen Teil über, wo die Anwesenden in kleineren Gruppen den Abend und weitere C++ Themen diskutierten, bis sich das Treffen dann auflöste.

C++ User-Treffen in Köln am 22.3.2016

Beim diesmaligen C++ User-Treffen in Köln war viel los - immerhin 24 C++ Interessierte waren gekommen. Ehrlich gesagt hatte dies aber niemanden überrascht - immerhin war Nicolai Josuttis als Sprecher angekündigt worden. Sein Thema waren die "Geheimnisse der Move-Semantik" - in meinen Augen eines der drei undurchsichtigsten und schwierigsten Themen von C++ - und bevor jemand fragt: die anderen Themen sind "Metaprogrammierung mit Templates und Constexpr" und natürlich "Multithreading", das in jeder Sprache eine hohe Kunst ist. Selbst wenn also Metaprogrammierung und MT noch komplexer sind, so ist schon die Move-Semantik ein ganz schöner Verständnis-Brocken - und so war es gut dass ein wirklich ausgewiesener C++ Experte den Abend übernommen hatte. Immerhin ist Nicolai Josuttis Mitglied des C++ Standardisierungs-Gremiums und Autor einiger C++ Bücher (darunter dem Standardwerk zur C++ Standard-Bibliothek).

Nico eröffnete den Abend mit einem typischen Move-Semantik Beispiel. Er zeigt an wenigen Zeilen Code, wie häufig in realem Code sinnlose tiefe Kopien erzeugt werden, obwohl doch flache Kopien vollkommen ausreichen würden. Diese Ersetzung von tiefen mit flachen Kopien nennen wir in C++ vielleicht nicht ganz korrekt "moven", da der Besitz der Hauptwerte "gemovt" wird. Der Trick der Move-Semantik ist, dass der Compiler dank des komplexen Typ-Systems von C++ viele solcher Situationen selbst erkennen kann, und neue Compiler ganz von sich aus ohne jegliche Code-Änderung performanteren Code erzeugen. Aber natürlich kann der Compiler nicht alle Situationen erkennen, und dann müssen wir mit "std::move" nachhelfen. Nico konnte beides überzeugend vorstellen und erklären.

Aus der Move-Semantik resultierte dann der Operator und die bedingte Exception-Spezifikation "noexcept", um einen effizienten Vektor mit starker Exception-Sicherheit implementieren zu können - die Zusammenhänge stellte Nico sehr aufschlussreich und überzeugend vor. Besonders interessant wurde es dann auch, als Nico vorstellte wie man die Move-Semantik durch Funktionen hindurchreichen kann - bzw. wenn eine generische Lösung für das Durchreichen von L-Value-Referenzen, Const-L-Value Referenzen und Move-Semantik benötigt wird. Hier sind dann "Forward-Referenzen" (bzw. "Universal-Referenzen", wie Scott Meyers sie genannt hat) und "std::forward" unser Freund. Dies und weitere "Geheimnisse der Move-Semantik" waren dann die schon eher Experten-Themen von Nico's Vortrag.

Am Ende war es ein sehr interessanter Abend für alle gewesen. Die vielen Fragen zwischendurch zeugten von den Unklarheiten bzgl. der Move-Semantik bei manchem Anwesenden - und so hat sicher jeder an dem Abend noch etwas gelernt. Ich jedenfalls konnte auch noch einige neue und interessante Denkanstöße mit nach Hause nehmen. Und sehr unterhaltsam waren auch die vielen kleinen Geschichten aus dem C++ Standardisierungs-Gremium, die Nico aus erster Hand erzählen konnte - und die zeigten, dass dort sicher echte C++ Experten sitzen, die aber auch mal Fehler machen und nicht immer direkt die ideale Lösung kennen.

Update 4.4.2016: die Folien von Nico stehen hier mittlerweile zur Verfügung.

C++ User-Treffen in Köln am 26.1.2016

Beim diesmaligen C++ User-Treffen in Köln ging es weniger um C++ selber, sondern um Continous-Integration im C++ Umfeld. Auch wenn der Abend also keine C++ Erkenntnisse versprach, waren doch 15 C++ Programmierer gekommen. Natürlich gehört auch das Tooling rund um C++ genauso zu den täglichen Themen wie die Sprache selber. Und von daher waren wir alle sehr interessiert mehr darüber zu hören.

Den ersten Teil des Abens übernahm Jan Steemann, und er hatte sich ein sehr ambitioniertes Ziel gesetzt: er wollte "live" einen kompletten Continous-Integration Workflow mit freien Services im Internet aufbauen, inkl. Builds unter Linux und Windows, und inkl. automatischer Test-Ausführung und Coverage-Reporting. Dazu erstellte Jan als erstes in Projekt-Repository auf GitHub und checkte ein kleines Beispiel Projekt ein. Dieses hatte er vorbereitet und konnte es lokal mit Hilfe von CMake erstellen. Danach meldete sich Jan bei Travis CI an. Travis CI bietet eine Build- und Test-Umgebung im Internet für Builds und Tests unter Linux und Mac OS-X. Für Linux konfigurierte Jan in einer YML-Datei die Builds und Tests für Travis CI, und verband dann GitHub mit Travis CI. Jeder "push" in das GitHub Repository führte nun direkt zum einem Neubau des Projekts unter Linux mit Travis CI - außerdem wurden noch direkt die automatischen Tests ausgeführt. Das gleiche zeigte er dann auch noch kurz für Windows mit AppVeyor. Danach konfigurierte Jan Travis CI so, dass noch zusätzlich Coverage-Daten bei den Tests mit erzeugt werden. Um die Coverage direkt zu reporten, nutzte er CoverAlls. Ein Ruby-Service in Travis CI lud nach dem Testlauf automatisch die Coverage-Ergebnisse nach CoverAlls hoch - und dort wurden sie direkt angezeigt.

Es war sehr beeindruckend zu sehen, welche leistungsfähigen Services im Internet frei (für Open-Source Projekte) zur Verfügung stehen, und wie einfach sie zu verbinden sind. Die Diskussionen und Fragen während des Vortrags zeigten, dass dies nicht nur mein Eindruck war. Jan's Vortrags-Folien stehen hier zum Download zur Verfügung.

Danach übernahm Uwe Arzt den zweiten Teil des Abends. Da Jan schon viel über Contious-Integration erzählt hatte, brauchte er hierauf nicht einzugehen. Statt dessen stellte er eine Inhouse-Lösung mit dem CI Tool Jenkins vor. Im Gegensatz zu Travis CI und AppVeyor wird der Jenkins nicht über YML-Dateien sondern grafisch in einer Web-Oberfläche konfiguriert - mit allen Vor- und Nachteilen. Außerdem kann man Jenkins mit Plugins stark erweitern und anpassen. Uwe berichtete von seinen praktischen Erfahrungen mit Jenkins und verschiedenen Lösungsmöglichkeiten und Fallen. Interessant waren seine Ausführungen vor allem auch, da er viele Build-Clients mit sehr unterschiedlichen Betriebssystemen einsetzt, und hier von manchen Herausforderungen und Lösungen berichten konnte.

Die vielen Fragen und Diskussionen während und nach den Vorträgen zeigten, wie sehr dieses Thema alle Programmierer betrifft. Viele Anwesende konnnten eigene Erfahrungen, Hinweise und Tipps zu CI Tools beisteuern - gerade der Jenkins fand sich relativ häufig im Erfahrungsschatz der Teilnehmer wieder. Unterm Strich war es ein sehr interessanter Abend, auch wenn es quasi keinen C++ Code zu sehen gab.

C++ User-Treffen in Köln am 24.11.2015

Diesmal war praktisches Programmieren beim C++ User-Treffen in Köln angesagt, und immerhin 12 C++ Programmierer waren gekommen um sich der praktischen Herausfoderung zu stellen. Holger Naussed hatte hierfür ein Code-Dojo mit Schwerpunkt Test-Driven-Development und STL-Algorithmen vorbereitet.

Der Abend began mit einer Einführung in Code-Dojos von Holger. Ein Code-Dojo ist eine Codierungs-Übung mit einem zugrunde liegenden Thema, in der typische Techniken trainiert und vertieft werden - in diesem Fall eben Test-Driven-Development und STL-Algorithmen.

Im Test-Driven-Development wird zuerst ein einzelner Unit-Test geschrieben (Test ist rot), der dann implementiert wird (Test ist grün) - danach steht Refactoring an (Test bleibt grün) bis alle Teilnehmer zufrieden sind. Danach geht es dann weiter mit dem nächsten Unit-Test. Durch die kleinen Schritte erzwingt TDD ein testbares Design, was nur notwendigen Code enthält.

In der Aufgabe selber sollte ein Buch-Text eingelesen und analysiert werden - wieviel Wörter enthält der Text und welches sind die längsten Wörter. Was genau Wörter sind, war bei der Aufgabe zum Teil festgelegt - zum Teil aber noch offen und musste von uns selbst festgelegt werden. Dabei durften keine Schleifen, keine Rekursion, kein "goto", "longjmp"s oder andere schleifen-ähnlichen Konstrukte verwendet werden - es sollten nur STL Algorithmen verwendet werden.

Jeder Teilnehmer konnte ungefähr 5 Minuten am Rechner sitzen, die Richtung bestimmen und coden - während die anderen Teilnehmer ihn auf Nachfrage unterstützten. Stück für Stück entwickelte sich so unsere Lösung. Einige Teilnehmer hatten große Probleme mit dem TDD Vorgehen und wollten statt dessen direkt den großen Wurf entwickelten. Die Vorteile der Schritt für Schritt Entwicklung und die Entstehung eines testbaren Designs waren ihnen nicht geläufig - und sie taten sich sehr schwer damit. Aber gerade für solche Entwickler sind Code-Dojos ja gedacht - wo sie unbekannte Techniken ohne Druck und mit viel Spaß üben können.

In der Retrospektive zeigte sich, dass das Code-Dojo den Teilnehmern viel Spaß gemacht hatte - und manch einer hatte hinterher auch ein bißchen (oder ein bißchen mehr) über TDD und die STL Algorithmen gelernt. Der Abend war damit aber noch lange nicht zuende - die Diskussion ging fließend in andere C++ Themen über. Am Ende war es wieder ein interessantes Treffen gewesen.

C++ User-Treffen in Köln am 29.09.2015

Auch diesmal war das C++ User-Treffen in Köln verschoben worden - aber diesmal nur um eine Woche - und so war es noch immer ein September-Treffen. 12 C++ Programmierer waren gekommen, um den Ausführungen von Uwe Arzt über die Grundlagen der Bild-Bearbeitung zu lauschen. Beim letzten Treffen war ja aufgefallen, wieviele Teilnehmer wenig oder gar keine Erfahrung mit Image-Processing hatten und daher viele elementare Begriffe nicht kannten. Und so hatte sich Uwe heute vorgenommen, diese Lücken zu füllen.

Und so began er ganz klein mit der Frage, wie das Bild überhaupt in den Computer kommt? Diese Frage beantwortete er mit dem Aufbau und der Arbeitsweise von Sensoren. In diesem Kontext stellte er Begriffe bzw. Effekte wie Graustufen, Bayer-Pattern, Filter, Rolling und Global Shuter vor. Damit waren die ersten Grundlagen gelegt und die Zuhörer kannten schon die ersten Probleme, die bei späteren Bearbeitungen berücksichtigt werden müßten.

Danach stellte Uwe verschiedene Farb- und Speichermodelle vor. Für viele Modelle hatte er kleine C++ Beispiele vorbereitet, die das Verhalten direkt am Bild demonstrieren konnten. Sehr interessant und beeindruckend war dabei seine Beispiele zu den Farbmodellen. Uwe hatte eine Figur vor einem blauen Hintergrund fotografiert, wobei der Hintergrund einfach ein blaues T-Shirt von ihm war. Während im RGB-Modell die Trennung der Farben nur einfache Graustufen-Bilder ohne Aussage erzeugte, konnte man bei der analogen Trennung im HSI-Modell sofort die Verwerfungen und Schattierungen des T-Shirts erkennen. Ähnlich beim Blueboxing-Beispiel, bei dem er versuchte den blauen Hintergrund durch einen grünen zu ersetzen. Während der Algorithmus im RGB-Modell einen breiten Farbbereich abdecken musste und trotzdem nicht vernünftig funktionierte, bestand der gleiche Algorithmus im HSI-Modell aus nur einem Vergleich, funktionierte dabei aber ganz problemlos und zerstörte auch nicht die Schattierungen des T-Shirts. Das waren ein paar echt eindrucksvolle Beispiele, dass allein die Wahl des Farb-Modells zwischen "einfach-und-funktioniert" und "kompliziert-und-funktioniert-nicht" entscheiden kann.

Als nächstes stellte Uwe Punkt-, lokale und globale Operatoren vor und ging dabei auch auf Randprobleme ein. Eins seiner Beispiele hierbei war die Kantenerkennung nach Sobel. Und natürlich hatte er auch hier einige kleine C++ Beispiele vorbereitet. Zum Schluß stellte er noch mehrere Image-Processing Algorithmen im Kontext von Videos vor und ließ sie live in C++ laufen. Er griff das Bild der im Laptop eingebauten Video-Kamera im C++ Programm ab und ließ eine Kantenerkennung darüber laufen und zeigte das Ergebnis direkt an - wir alle konnten uns nun als Konturen sehen. Das Gleiche machte er mit einem Differenz-Algorithmus, der nur die Unterschiede zum vorherigen Bild zeigte - nur Bewegungen von uns führten zu einem sichtbaren Ergebnis.

Alle Beispiele hatte Uwe mit der Image-Processing Bibliothek "OpenCV" umgesetzt, die alle diese Algorithmen (und viele mehr) direkt enthält. Damit waren alle Beispiele nur wenige Zeilen lang und konnten einfach nachvollzogen werden. Uwe erzählte dann noch etwas über OpenCV und auch über einige andere Image-Bibliotheken - wie z.B. über Boost.GIL vom letzten Treffen.

Unterm Strich war es ein sehr interessanter Abend mit einem spannenden Vortrag und einigen sehr beeindruckenden Beispielen. Wer nicht da war, hat echt was verpaßt - aber zum Glück gibt es die Präsentation und alle Sourcen auf GitHub.

C++ User-Treffen in Köln am 18.08.2015

Endlich fand das eigentlich für Juli geplante C++ User-Treffen in Köln statt - der Termin war ja recht kurzfristig verschoben und dann der Ersatz-Termin auch nur sehr kurzfristig kommuniziert worden. Trotzdem hatten sich immerhin 10 C++ Interessierte eingefunden - andere konnten aufgrund der kurzfristigen Planung nicht kommen und hatten im Vorfeld abgesagt. Daniel Oberhoff hatte den Abend übernommen, und erfreute uns mit einem Vortrag über die Boost Graphic-Image-Library "Boost.GIL"

GIL ist nicht einfach eine Ansammlung von Image-Processing Funktionen, sondern im Gegenteil erstmal eher eine konzeptionelle Abbildung der Domän "Image-Processing" in C++ Templates, die aber auch fertige Klassen und Algorithmen enthält. Und so begann Daniels Vortrag auch erstmal recht theoretisch, indem er die Konzepte von GIL und ihre Beziehungen untereinander vorstellte - und so entpuppte sich z.B. ein einfacher Pixel auf einmal als ein recht komplexes Gebilde aus Channels und Farb-Modellen, der über Locatoren auf einem virtuellen View erreicht werden kann.

Einige der Anwesenden hatten schon einige Erfahrung mit Image-Processing gesammelt und waren direkt zuhause, während andere komplette Neulinge waren - und so begleitete die Vorstellung der GIL Konzepte eine ständige Diskussion, in der dann elementare Begriffe wie z.B. Channel und Alpha-Kanal, aber auch detailliertere Themen wie Speicher-Abbildungen und Z-Ordering erklärt wurden. Ganz unabhängig von "GIL" hat sich für die Neulinge in dem Bereich "Image-Processing" der Abend sicher schon alleine wegen dieser Erklärungen gelohnt.

Zum Glück blieb es nicht bei der Theorie: Daniel hatte ein Programm mitgebracht, dass Höhen-Reliefs einlesen konnte und dann die Höhenlinien mit Hilfe von "GIL" visualisierte. Aber wir hatten Blut geleckt und wollten mehr. Im Vortrag hatte er die Verknüpfung von Image-Transformationen in Form von Pseudo-Code gezeigt - und wir wollten das Laufen sehen. Und so setzte er sich hin und brachte den Pseudo-Code zum Leben: in erster Linie fügte er nur die fehlenden Includes ein, wrappte den Code in "main" und fügte einige "auto"s ein, um die Variablen automatisch zu typisieren. Und dann konnten wir Bilder schon bearbeiten: Rotieren, Verzerren, Farb-Channels ausblenden und vieles mehr.

Parallel zu Daniels "Live-Coding" zeigte uns Uwe spontan die Image-Processing Bibliothek "OpenCV", die ja auch ein Bestandteil von Cinder ist - siehe letzten Bericht aus Köln. Nachdem wir "GIL" nun kennengelernt hatten, war der Vergleich mit "OpenCV" oder auch "Dlib" sehr interessant, und löste viele Fragen und Diskussionen aus, und so war der Abend noch lange nicht zuende.

C++ User-Treffen in Köln am 26.05.2015

Und wieder fand ein C++ User-Treffen in Köln statt, und diesmal hatte ich den "Abend" übernommen. Auch hier - wie schon letzte Woche in Düsseldorf - führte ich wieder meine C++ Kochshow vor und "kochte" gemeinsam mit den 10 weiteren Anwesenden ein echtes kleines C++ Programm.

In rund 2 Stunden entwickelte ich mit den Anwesenden zusammen in 24 Schritten ein kleines Asteroids Spiel mit Hilfe der C++ Bibliothek Cinder. Was die eigentliche C++ Kochshow und Details zum Spiel angeht - wer da mehr wissen will, kann dies am Besten im Bericht aus Düsseldorf nachlesen. Interessanter sind hier die Unterschiede zu letzter Woche.

Wie schon letzte Woche in Düsseldorf ergaben sich auch hier reichlich Fragen von den Teilnehmern zu Details von Cinder oder zu meinem Code. Im Gegensatz zu letzter Woche saßen diesmal aber scheinbar ein paar Spiele-Experten im Publikum - die Fragen über Cinder erreichten schnell eine Tiefe, der ich nicht gewachsen war. Und die Anwesenden fanden auch noch einige "Bugs" in meinem Code - dem war das lange Schmoren im "Backofen" wohl nicht bekommen. Ein Teil der "Bugs" waren bewußte pragmatische Entscheidungen von mir während des Codierens gewesen (z.B. frame-based statt time-based zu Arbeiten, oder die Reduktion aller Figuren auf Kreise für die Kollisions-Berechnung) - andere waren echte Bugs, die mir noch nicht aufgefallen waren (z.B. die fehlende Kollisions-Erkennung über Kanten hinweg). Unterm Strich brachte auch mir die Diskussion manchen Erkenntnis-Gewinn - und sei es nur die Erfahrung, doch besser keinen "echten" Code zu zeigen sondern bei Folien zu bleiben.

Auch hinterher ergab sich noch manche Diskussion über die verschiedensten Themen von C++ - gerade Smart-Pointer und Performance waren heiß diskutierte Themen. Aber auch Monaden, Debugging, Bug-Stories und manches andere tauchte auf. Die Zeit verging wie im Flug, und so löste sich das Treffen endgültig erst gegen ca. 23:30 auf.

C++ User-Treffen in Köln am 24.03.2015

Diesmal hatte ich es geschafft, und konnte am C++ User-Treffen in Köln teilnehmen. Und mit mir waren 11 weitere Teilnehmer gekommen - u.a. wieder einige von der Firma ParStream selber. Am Anfang führten wir eine kurze Vorstellungs-Runde durch, denn viele Teilnehmer waren wie ich das erste Mal da. Dann übernahm Michael Wielpütz den aktiven Part - er hatte einen Vortrag über C++11 Lambdas vorbereitet. Schon während der Präsentation - aber noch viel mehr hinterher - entwickelten sich eine Menge Diskussionen über den Einsatz von Lambdas und ihre Vor- und Nachteile, aber auch über manche Details des Standards selber, oder die Erweiterungen in C++14.

Im Laufe des Abends verschoben sich die Themen dann immer mehr weg von den konkreten Lambdas zu allgemeinen Themen von C++, den Schwerpunkten der Teilnehmer (wie z.B. Embedded-Systeme oder Audio Verfahren) und die Durchführung von User-Treffen. So wurden u.a. Code-Dojos vorgestellt und diskutiert. Dabei wurde dann auch beschlossen, dass die C++ User-Treffen in Köln ab jetzt regelmäßig am jeweils vierten Dienstag der geraden Monate erfolgen sollen.

C++ User-Treffen in Köln am 23.02.2015

Das zweite Treffen der C++ User-Gruppe Köln fand in einem ungewohnten Rahmen statt. Die Library Working Group der C++ Standardisierung traf sich die gesamte Woche in Köln, und am Montag Abend gab es einen öffentlichen Vortrag von Christopher Kohlhoff, dem Autor von Boost.Asio und dem Proposal "n4370" über Networking im kommenden C++ Standard C++17. Das Thema des Vortrags war "Threads are an Illusion - A guide to thinking about Program Design with Boost.Asio".

Der Vortrag fand im Hotel Mediapark statt, wo die Library Working Group tagte. Über 50 Leute - unter ihnen viele Mitglieder der Library Working Group - waren zu diesem Vortrag gekommen - und so wurde es ganz schön voll. Den Vortrag leitete Nicolai Josuttis ein - dann war Christopher an der Reihe. Sein Vortrag drehte sich natürlich um Boost.Asio, und wie mit Boost.Asio effiziente asynchrone Programme gestaltet werden können, ohne dass Threads notwendig sind. Wen die Details interessieren - Jens Weller hat den Vortrag aufgezeichnet und auf YouTube veröffentlicht. Die Folien finden sich hier auf Google-Drive.

Besonders spannend an diesem Abend war es zumindest für mich, hinterher mit vielen Mitgliedern der Library Working Group in der Hotel-Bar zu fachsimpeln, und zu versuchen einige Ideen und Präferenzen bzgl. C++17 anbringen zu können.

C++ User-Treffen in Köln am 11.12.2014

Am ersten C++ User-Treffen in Köln konnte ich leider nicht teilnehmen. Ich hatte mir zwar vorgenommen, dass Gründungstreffen zu besuchen, aber an dem Abend konnte ich dann doch nicht.

Wie ich hinterher von Michael Wielpütz - dem Organisator des C++ User-Treffens - gehört habe, waren rund 10 C++ Entwickler anwesend - die meisten von der Firma ParStream, wo das Treffen auch ausgerichtet wurde. Michael Wielpütz und Thorsten Wendt hatten einen Vortrag über den "Einfluss von Memory-Barrieren auf Smart Pointer" vorbereitet. Hierbei ging es um die Auswirkungen auf die Performance, z.B. durch die intensive Nutzung von Speicherbarrieren, die ein Umsortieren der Prozessor-Instruktionen verhindern. Außerdem wurden die grundlegenden Mechanismen zur Synchronisation von Caches in SMP-Systemen und die sich daraus ergebenden Konsequenzen für die Nutzung von Smart-Pointern und ähnlichen Sprachkonstrukten erläutert.


C++ User-Treffen: