Software – Magie oder ?

An manchen Tagen zeigt sich die magische Seite der Softwareentwicklung. Magisch ist alles, was dem Ungelernten verborgen ist. Manchmal aber glauben auch die Gelernten und die, die meinen etwas gelernt zu haben, an Magie.

An diesem Montag verhielt sich die Software anders als am Freitag. Von den schönen Bildern, die ich im letzten Beitrag schilderte, zeigte sich keines.

Magisch war an dieser Stelle noch nichts. Immerhin verwendete die Software Teile von anderen Projekten und bei einem neuerlichen Zusammenbau am Montag konnte es passieren, dass eben etwas nicht stimmte.

Obwohl? Unsere Oberfläche hat ihre eigenen Icons, die von unserem UX-Designer gemalt wurden. Warum nur wurden sie nicht gefunden?

Ich forschte den ganzen Tag. Am Ende zeigten sich die Bilder wieder. Die Ursache schien aber magisch zu sein!

„Software – Magie oder ?“ weiterlesen

Icon – drei Irrwege

Unsere Oberfläche muss in ihrer Auflösung den modernen Bildschirmen anpassen!

Die ganz wichtigen Kunden haben Bildschirme mit nahezu Apple Auflösung. Da kommen die kleinen 16 mal 16 Pixel großen Button nicht gut. Wenn Windows das automatisch anpasst, sieht das eckig und verschwommen aus. Ohne Anpassung sind die Schaltflächen so klein, dass kein Kunde sie findet.

Deswegen gilt es auf zu hübschen!

Der UX Designer hat schon skalierbare Icons für alle Button Bitmaps entworfen. Entscheidungsträger haben sich darüber versammelt und endgültige Versionen beschlossen.

Ich brauchte sie nur noch einzubauen. Das muss Pillepalle sein und ich wollte es nebenher erledigen.

Da wir Win32 API verwenden, muss ich die Icons zu Bitmaps im BMP Format konvertieren. Der UX Designer hat aus den Icons Bitmaps im PNG-Format in verschiedenen Auflösungen erzeugt.

Das einzige Problem war die Toolbar API. Hier kommen Imagelists zum Einsatz. Es galt die Bitmaps zu „Bitmapstripes“ zu verknüpfen.

Das sollte doch einfach sein. Was konnte da schiefgehen?

„Icon – drei Irrwege“ weiterlesen

Dreimal C++ – lambdas in legacy code

Wie schon zuletzt beschrieben, galt es C++ Software aus einem Nachbarprojekt zu übernehmen. Die dort tätigen Kollegen verwendeten begeistert die Features von C++ 2014. Vor allem der Datentyp „auto“ und die Initialisierung mit geschweiften Klammern hatte es ihnen angetan. Auch setzten sie shared_ptr und unique_ptr ein. Falls diese dann doch mit traditionellen Pointer darunter mischen, startet unter Umständen eine interessante Fehlersuche.

Aber mich interessierte die Art und Weise wie sie lambdas einbauten. Ich suchte nach eckigen Klammer gefolgt von einer geöffneten Klammer und konnte drei Sorten identifizieren:

  1. lokale Subroutinen (hätte man auch mit #defines machen können)
  2. Abräumer von von Windows handles (scope guard, geht kaum ohne lambdas)
  3. zur Initialisierung von static Variablen (das fand ich cool)

„Dreimal C++ – lambdas in legacy code“ weiterlesen

c++ im Jahr 2019: lambda und diskette

Was ich neulich im Job sah, warf mich förmlich um. Zum ersten Mal sah ich C++ lambda Ausdrücke in einem in die Jahre gekommen Softwarestapel. Es war sogar eine richtig praktische Anwendung, an die die Erfinder dieser neuen Sprachfeatures nicht gedacht hatten:


auto const fDoEvents = [&]()
     ProcessMessagesForCurrentProcessMainWindow();
     ProcessAfxMessagePump();
};
fDoEvents();

// vollen Refresh auslösen
xy->AddChanges(CTRL_NAV_RESULT);
z->Refresh(CTRL_NAV_CURR, true);
fDoEvents();

Das lambda fasste Statements zusammen, die in einem Spaghetticode immer wieder zu wiederholen sind. Hier war es immer mal wieder Messages zu bearbeiten. In der guten(?), alten Zeit hätten #define macros herhalten müssen.

In unmittelbarer Nähe, ein paar Zeilen unter dem zweiten Aufruf von fDoEvent()  befand sich ein Kommentar mit der Diskette:

// TODO: OFL aktualisieren (Dirtyflag / Diskette zurücksetzen)

Nach dem ersten Lachen stellte sich die Frage, wie dieser Kommentar in den Source kam.

Die Datei wurde laut tfs um 2015 geschrieben.

Die zweite Frage, war die, wie lambda Ausdrücke in den neuen C++ Standards funktioneren?

Das lud mich dann ein hierzu etwas zu schreiben.

„c++ im Jahr 2019: lambda und diskette“ weiterlesen

const char * und CString — täglich grüßt das Murmeltier

Ich fühlte mich wie in besagtem Film. Es ging um die Frage, warum die Software so lange braucht, obwohl nur wenig Daten zu verarbeiten waren. Zwar hatten sich die Kunden bestimmt schon an die Zwangspause gewöhnt, aber trotzdem sollte das doch mal schneller gehen. Wir könnten einen guten Eindruck machen, wenn es ein wenig schneller ginge mit der Erstellung einer Ausgabedatei.

Es gab eine ältere Fehlermeldung die etwas von einer ganz langen Erstellung einer solchen Ausgabe beschrieb. Die Datenbank lief auf einem eigenen Server. Die Anwendungssoftware auf einem Clientrechner.  Für mich deutete das auf ein Problem im Netz hin. Vermutlich war der merkwürdige Datenzugriff schuld. Die Anwendung war auf C-Isam zugeschnitten und nutzte SQL nur zum atomaren Zugriff auf Datensätze.

Das wollte ich zeigen. Es sollte einfach sein. War aber dann ganz anders.

„const char * und CString — täglich grüßt das Murmeltier“ weiterlesen

Legacy Code — Exe schläft nach Kaltstart

Endlich kam eine interessante Aufgabe. Eine Aufgabe, die typisch für Legacy Code war. Die schon in die Jahre gekommene Anwendung zeigte mit jeder neuen Version einen schlechteren Kaltstart. Wenn sie zum ersten Mal gestartet wurde, fror sie für einige Zeit ein. Diese Zeit wurde von Version zu Version immer länger. In der aktuellen Version konnten es mehrere Minuten sein.

Zwar hatten sich die Anwender schon an einen Verzug gewöhnt. Nun sollte wenigstens ein Grund für diesen Verzug gefunden werden. Eine Behebung sollte anschließend geplant werden.

Wie freute ich mich auf diese Aufgabe!

„Legacy Code — Exe schläft nach Kaltstart“ weiterlesen

boolVariable = !! BoolVariable, was will der C++ Source mitteilen?

Ich staunte nicht schlecht, als ich die zwei ! Zeichen sah.  Was sollte das?

War das ein Versehen? Hat da jemand den not-Operators überladen?

Es waren immer Stellen wie diese:

bIsOpen = !!mPtr->openFile(….) ;

Nachdem ich das zum ersten Mal gesehen hatte, entdeckte ich die doppelte Verneinung an immer mehr Stellen, in dem C++-Source, den zu warten ich für dieses Jahr übernommen hatte.

Um 20005 herum war es einmal eine Art Richtlinie. Was für einen Sinn das wohl gehabt hatte?

Ich forschte nach und bekam Antworten und Ergebnisse, die mich dann doch überraschten.

„boolVariable = !! BoolVariable, was will der C++ Source mitteilen?“ weiterlesen