~/blog/2015/12/cppbuilder-10-seattle-lohnt-das-up.md

C++Builder 10 Seattle: Lohnt das Upgrade?

5 min
Titelgrafik: C++Builder 10 Seattle – Lohnt das Upgrade?

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • C++Builder 10 Seattle (RAD Studio 10) erschien am 31. August 2015 und bringt den Clang-basierten Compiler bcc32c auch für Win32 mit, damit C++11 für 32 Bit.
  • Dazu kommen Windows-10-Unterstützung samt VCL-Styles, Weiterentwicklung von FireMonkey und eine IDE, die mehr Arbeitsspeicher nutzen kann.
  • Das eigentliche Risiko liegt im Altbestand: Komponenten von Drittanbietern und bcc32-spezifischer Code müssen sorgfältig getestet werden.
  • Der klassische Compiler bleibt verfügbar, ein schrittweiser Umstieg ist möglich.

Seit einigen Wochen ist C++Builder 10 Seattle auf dem Markt, und ich habe mir mit dem Schreiben dieses Artikels bewusst Zeit gelassen. Bei einer Entwicklungsumgebung, auf der langlebige Anwendungen stehen, ist der erste Eindruck nicht der wichtige. Wichtig ist, was nach zwei, drei Monaten übrig bleibt, wenn man ein echtes Projekt hindurchgezogen hat. Ich versuche deshalb gar nicht erst, eine Testreihe vorzutäuschen, sondern ordne ein, was an der Version meiner Meinung nach zählt und was man vor einem Umstieg bedenken sollte.

Der Compiler ist die Geschichte

Das große Thema ist der Compiler. Clang als Grundlage kannte man im C++Builder schon aus den 64-Bit- und mobilen Zielen. In Seattle gibt es nun auch für Win32 einen Compiler auf dieser Grundlage, den bcc32c. Damit bekommt die 32-Bit-Welt, in der die meisten bestehenden VCL-Anwendungen leben, Zugriff auf C++11. Wer bisher mit dem klassischen bcc32 gearbeitet hat, kennt die Lage: Der Compiler war über Jahre ein Hemmnis, wenn man Bibliotheken von außen nutzen wollte, die moderne Sprachmittel voraussetzen. Lambdas, auto, Range-basierte for-Schleifen, nullptr, Move-Semantik: Das alles gehört zum Alltag anderer Compiler seit Jahren und war im C++Builder für 32 Bit schlicht nicht verfügbar.

Ich halte das für den wichtigsten Schritt der Version, nicht weil man plötzlich alles umschreiben müsste, sondern weil es die Verfügbarkeit moderner Bibliotheken verändert. Standardbibliothek, Boost-Teile und andere externe Quellen lassen sich mit einem aktuellen Compiler deutlich eher übersetzen. Das Gefühl, bei jeder neuen Bibliothek erst nachsehen zu müssen, ob sie mit dem eigenen Compiler überhaupt geht, wird kleiner. Wie weit der Standard im Detail unterstützt wird, würde ich allerdings nicht aus dem Bauch beurteilen. Es ist ein Compiler, der auf einem etablierten Frontend beruht, aber er muss im Zusammenspiel mit VCL, mit Delphi-Eigenheiten und mit dem Linker des Builders funktionieren, und genau dort können Besonderheiten auftauchen.

Was drumherum dazukommt

Neben dem Compiler gibt es die erwartbaren Dinge. Windows 10 ist seit Ende Juli draußen, und Seattle wurde darauf ausgerichtet; dazu gehören Anpassungen in der VCL und zusätzliche VCL-Styles, die zum Aussehen von Windows 10 passen. Für klassische Desktop-Anwendungen ist das mehr als Kosmetik, weil Anwender erwarten, dass eine Anwendung nicht aus der Zeit gefallen wirkt. FireMonkey wird weiterentwickelt, und zwar mit dem Ziel, die plattformübergreifende Oberfläche zu verbessern. Wer FireMonkey bislang eher zurückhaltend betrachtet hat, so wie ich, sollte es sich ansehen, aber ich würde es nicht pauschal als Ersatz der VCL betrachten.

Eine Änderung, die ich unterschätzt hätte: Die IDE kann mehr Arbeitsspeicher nutzen. Sie ist nun als Large Address Aware markiert, kann also mehr als zwei Gigabyte adressieren. Wer große Projekte mit vielen Paketen geöffnet hat, kennt die Situation, in der die IDE irgendwann seltsame Fehlermeldungen wegen Speichermangels zeigt, obwohl der Rechner genug Reserve hat. Dass das jetzt entschärft wird, ist eine dieser Änderungen, die in keiner Werbung glänzen und im Alltag erheblich zählen.

Wo es haken kann

Der interessante Teil ist der Umstieg selbst. Wer ein bestehendes Projekt mit dem neuen Compiler übersetzen will, stellt wahrscheinlich fest, dass nicht alles so durchläuft, wie es mit bcc32 lief. Der klassische Compiler hat im Lauf der Jahre eigene Gewohnheiten gehabt, die sich im Code festsetzen: Erweiterungen wie __property, __closure oder __fastcall gehören zum Handwerkszeug des Builders, und manche Konstrukte waren großzügiger geduldet, als es der Standard vorsieht. Ein strengerer Compiler zeigt solche Stellen zuverlässig an, und man sollte die Meldungen als Gewinn lesen, nicht als Ärgernis. Auch wenn sich der Aufwand im Einzelnen schwer vorhersagen lässt, lohnt es sich, ihn nicht zu unterschätzen.

Das größere Risiko liegt meiner Erfahrung nach außerhalb des eigenen Codes. Komponenten von Drittanbietern und Pakete, die über Jahre mitgewachsen sind, müssen für den neuen Compiler neu übersetzt werden, und manche gibt es dafür vielleicht nicht, oder nur in einer neuen Version zum Kaufen. Bevor man sich für ein Upgrade entscheidet, sollte man eine Liste aller Abhängigkeiten erstellen, die im Projekt stecken, und bei jeder klären, ob sie für Seattle zur Verfügung steht. Das klingt langweilig, aber an dieser Liste entscheidet sich meist, ob ein Umstieg ein Nachmittag oder ein Quartal wird.

Auch das Linken kann Überraschungen bringen. Objektdateien und Bibliotheken, die mit dem alten Compiler erzeugt wurden, lassen sich nicht ohne Weiteres mit Code des neuen mischen. Wer fertige Bibliotheken in binärer Form im Projekt hat und keinen Quelltext dazu, ist hier am verwundbarsten.

Alt und neu nebeneinander

Eine Beruhigung gibt es: Der klassische Compiler ist in Seattle weiterhin dabei. Man kann also Projekt für Projekt entscheiden und muss nicht alles gleichzeitig umstellen. Das ist für mich der entscheidende Punkt bei der Abwägung. Ein Upgrade der IDE, ohne den Compiler zu wechseln, bringt bereits die Windows-10-Anpassungen und die bessere Speicherverwaltung. Der Wechsel des Compilers lässt sich danach an einem kleinen, gut überschaubaren Projekt erproben, bevor man die großen Anwendungen anfasst.

Vor einiger Zeit habe ich über die Umstellung auf 64 Bit geschrieben, und im Jahr davor über Unicode. Beide Male war der Ablauf ähnlich: Der Wechsel selbst war technisch beherrschbar, aufwendig waren die Altlasten, vor allem fremde Komponenten und Annahmen, die irgendwann im Code festgeschrieben wurden, etwa über die Größe von Zeigern oder die Breite von Zeichen. Bei Seattle erwarte ich dasselbe Muster. Wer damals sauber getrennt, konsequent mit Typen wie UnicodeString und NativeInt gearbeitet und Compiler-Eigenheiten gekapselt hat, wird es leichter haben.

Meine Einschätzung

Ob sich das Upgrade lohnt, hängt weniger von der Version als vom eigenen Bestand ab. Wer ein überschaubares Projekt mit wenigen Fremdkomponenten hat und C++11 oder aktuelle Bibliotheken nutzen möchte, für den sehe ich gute Gründe, jetzt zu wechseln. Wer eine große, über Jahre gewachsene Anwendung mit vielen Drittanbieter-Paketen und viel bcc32-spezifischem Code pflegt, sollte nicht drängeln. Ein sorgfältiger Test an einer Kopie, eine Abhängigkeitsliste und ein ehrlicher Blick auf die Bereitschaft der Anbieter sind mehr wert als der Wunsch, vorn dabei zu sein.

Preise und Lizenzmodelle lasse ich hier bewusst außen vor, die ändern sich und sollte man beim Hersteller nachsehen. Mir geht es um die technische Frage. Und die beantworte ich aktuell so: Neugierig sein, auf einer Kopie testen, und den Umstieg dann vornehmen, wenn die eigenen Abhängigkeiten ihn mittragen.

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.