In dieser Folge spricht Richard Seidl mit Sabina Lammert über wirkungsvolle Retrospektiven. Gemeinsam gehen sie der Frage nach, warum Retrospektiven Teams echte Veränderung ermöglichen – vorausgesetzt, sie werden richtig gestaltet. Sabina Lammert beschreibt, wie zentrale Aspekte wie Vertrauensräume, Prime Directive und methodische Phasen zu nachhaltiger Verbesserung beitragen und welche typischen Stolperfallen es zu vermeiden gilt. Besonders spannend: Wie sich der richtige Themenfokus und alltagstaugliche Maßnahmen auf die Wirksamkeit auswirken.

Bei diesem Podcast dreht sich alles um Softwarequalität: Ob Testautomatisierung, Qualität in agilen Projekten, Testdaten oder Testteams – Richard Seidl und seine Gäste schauen sich Dinge an, die mehr Qualität in die Softwareentwicklung bringen.

Die aktuelle Ausgabe ist auch auf Richard Seidls Blog verfügbar: „Retrospektiven richtig gemacht – Sabina Lammert“ und steht auf YouTube bereit.

(mai)

Was zeichnet gute Conversational AI eigentlich aus? Welche Prinzipen braucht es für eine gezielte Gestaltung? Darüber unterhalten sich Dominique Winter und Oliver Winter in dieser Folge des Podcasts. Sie klären, wie sich digitale Produkte verändern, wenn Sprache zur primären Schnittstelle wird. Denn sobald man sich mit Systemen unterhält, entsteht etwas, das weit über Funktion hinausgeht: Beziehung. Und diese will gestaltet sein.

KI in der Kommunikation: Mehr als ein Werkzeug

Conversational AI ist dabei nicht einfach ein neues Interface. Sie bringt einen neuen Faktor in die Produktentwicklung. Früher waren digitale Produkte vor allem Werkzeuge – heute können sie zu Gesprächspartnern werden. Das verändert Erwartungen, Erleben und Verantwortung bei der Gestaltung. Wer mit Chatbots, Sprachassistenten oder GPT-Integration arbeitet, muss mehr tun als ein paar gute Prompts schreiben. Es geht um Haltung, Verhalten und Beziehung.

Doch dann stellt sich die Frage: Welche Rolle soll die Conversational AI im Produkt einnehmen? Ist sie ein einmaliger Helfer oder ein persönlicher Assistent? Entsteht eine flüchtige Begegnung oder eine langfristige Interaktion? Und wie spiegelt sich das in Sprache, Ton, Humor oder Autonomie wider? Dominique beschreibt, wie Werte und Prinzipien einer Organisation sich konkret in Conversational AI übersetzen lassen – über Tonalität, Reaktionen, Grenzen und Masterprompts.

Interessant ist dabei auch die Rückkopplung Mensch-Maschine, bei dem eine Conversational AI „lernt“, was Nutzerinnen und Nutzer wollen oder brauchen. Lernen ist dabei aber nicht nur Sache der Maschine, sondern auch die Teams hinter dem Produkt müssen beobachten, reflektieren und nachschärfen. Denn User geben Feedback – implizit, durch Nutzung, Sprache, Abbrüche oder Überraschung. Diese Rückmeldungen gilt es ernst zu nehmen. Wer sie ignoriert, verschenkt Entwicklungspotenzial.

Gleichzeitig braucht es Verantwortung. Technisch ist vieles möglich – doch nicht alles sinnvoll. Dark Patterns funktionieren auch in Sprachinterfaces. Doch wer Beziehung aufbauen will, braucht Vertrauen. Und wer Vertrauen will, muss Haltung zeigen. Auch das ist Teil von Conversational AI: ethische Klarheit, bewusste Gestaltung, respektvoller Umgang.

Weiterführende Links

• Dominique verweist einmal auf die Podcastfolge zum Decision Stack. Dabei bezieht er sich auf die Abhängigkeit von Unternehmenswerten und den Werten, die das Produkt zum Ausdruck bringt.
• Oliver erwähnt die Folge der „Sendung mit der Maus„, die in sehr einfacher Form vermittelt, was wir heutzutage unter KI verstehen. Auch für Erwachsene sehenswert.

Die aktuelle Ausgabe des Podcasts steht auch im Blog der Produktwerker bereit: „Designprinzipien für Conversational AI„.

(mai)

Nachdem ich in meinem letzten Artikel Neuerungen in C++26: Datenparallele Typen (SIMD) eine theoretische Einführung in das neue Feature von C++ 26 gegeben habe, möchte ich heute mit einem praktischen Beispiel fortfahren.

Das folgende Einführungsbeispiel stammt aus der experimentellen Implementierung der SIMD-Bibliothek. Diese Funktionalität wurde unter dem Namen „Data-parallel types (SIMD)“ vollständig in den Entwurf für C++ 26 übernommen. Um das Programm auf den C++ 26-Standard zu portieren, sollte es ausreichen, den Header durch und den Namespace std::experimental durch std::datapar zu ersetzen.

#include 
#include 
#include 
namespace stdx = std::experimental;
 
void println(std::string_view name, auto const& a)
{
    std::cout << name << „: “;
    for (std::size_t i{}; i != std::size(a); ++i)
        
std::cout << a[i] << ‚ ‘;
    std::cout << ‚\n‘;
}
 
template
stdx::simd my_abs(stdx::simd x)
{
    where(x < 0, x) = -x;
    return x;
}
 
int main()
{
    const stdx::native_simd a = 1;
    println(„a“, a);
 
    const stdx::native_simd b([](int i) { return i - 2; });
    println(„b“, b);
     
const auto c = a + b;
    println(„c“, c);
 
const auto d = my_abs(c);
println(‚d‘, d);
 
const auto e = d * d;
println(„e“, e);
     
const auto inner_product = stdx::reduce(e);
    std::cout << „inner product: “ << inner_product << ‚\n‘;
 
const stdx::fixed_size_simd x([](int i) { return i; });
println(„x“, x);
    
println(„cos²(x) + sin²(x)“, stdx::pow(stdx::cos(x), 2) + stdx::pow(stdx::sin(x), 2));
}

Bevor ich mit dem Programm fortfahre, möchte ich die Ausgabe vorstellen.

Zuerst möchte ich mich den Funktionen println und my_abs widmen. println gibt den Namen und den Inhalt eines SIMD-Vektors aus und durchläuft dabei dessen Elemente. my_abs berechnet den Absolutwert jedes Elements in einem SIMD-Vektor mit Ganzzahlen und verwendet dabei where, um negative Werte bedingt zu negieren. Deutlich interessanter ist die main-Funktion.

Bei dem SIMD-Vektor a wird jedes Element auf 1 gesetzt, hingegen wird bei dem SIMD-Vektor b dank der Lambda-Funktion jedes Element so initialisiert, dass dieses seinen Index minus 2 besitzt. Dabei kommen per Default durch const stdx::native_simd SSE2-Instruktionen zum Einsatz. Diese SIMD-Vektoren sind 128 Bit groß.

Nun beginnt die Arithmetik. Vektor c ist die elementweise Summe von a und b, d ist der elementweise absolute Wert von c und der Vektor e ist das elementweise Quadrat von d. Zuletzt kommt stdx::reduce(e) zum Einsatz. Dabei wird der Vektor e auf seine Summe reduziert.

Besonders interessant ist der Ausdruck const stdx::fixed_size_simd x([](int i) { return i; }). Durch ihn wird der SIMD-Vektor x mit 16 long-double-Werten von 0 bis 15 initialisiert. Das ist möglich, wenn die Hardware hinreichend modern ist und AVX-252 unterstützt, beispielsweise mit Intels Xeon-Phi- oder AMDs Zen-4-Architektur.

Ähnlich interessant ist die Zeile println("cos²(x) + sin²(x)", stdx::pow(stdx::cos(x), 2) + stdx::pow(stdx::sin(x), 2)). Sie berechnet cos²(x) + sin²(x) für jedes Element, was aufgrund der trigonometrischen Identität des Pythagoras für alle Elemente 1 ist. Es gilt, dass alle Funktionen in außer den speziellen mathematischen Funktionen für simd überladen sind. Dies sind zum Beispiel die grundlegenden Funktionen wie abs, min oder max. Aber auch zum Beispiel exponentielle, trigonometrische, hyperbolische, Potenz- oder Gamma-Funktionen lassen sich direkt auf SIMD Vektor anwenden.

Nun möchte ich noch auf die Breite des Datentyps simd genauer eingehen.

Breite von simd

Die Breite des Datentyps native_simd wird durch die Implementierung zur Compile-Zeit bestimmt. Im Gegensatz dazu gibt der Entwickler die Breite des Datentyps fixed_size_simd vor.

Das Klassen-Template simd besitzt folgende Deklaration:

template< class T, class Abi = simd_abi::compatible >
class simd;

Dabei steht T für den Elementtyp, der nicht bool sein kann. Durch den Abi-Tag wird die Anzahl der Elemente und deren Speicher bestimmt.

Zu diesem Klassen-Template gibt es zwei Aliase:

template< class T, int N >
using fixed_size_simd = std::experimental::simd>;
template< class T >
using native_simd = std::experimental::simd>;

Folgende ABI-Tags stehen zur Verfügung:

• scalar: Speicherung eines einzelnen Elements
• fixed_size: Speicherung einer bestimmten Anzahl von Elementen
• compatible: gewährleistet ABI-Kompatibilität
• native: am effizientesten
• max_fixed_size: maximale Anzahl von Elementen, die garantiert von fixed_size unterstützt werden

Wie geht’s weiter?

Nach diesem ersten Beispiel zu datenparallelen Typen möchte ich im nächsten Artikel genauer auf deren Funktionalität eingehen.

(rme)