The Role of Language Bindings in the Future of the Qt Ecosystem.

Dr. Cristián Maureira-Fredes
@cmaureir

Yesterday's talk

Qt Roadmap

Volker & Maurice
(QtWS23)

        #ifndef MAINWINDOW_H
        #define MAINWINDOW_H

        #include <QMainWindow>
        #include <QPushButton>

        class MainWindow : public QMainWindow
        {
            Q_OBJECT
            public:
                MainWindow(QWidget *parent = nullptr);
            private slots:
                void handleButton();
            private:
                QPushButton *m_button;
        };

        #endif // MAINWINDOW_H

        #include "mainwindow.h"

        MainWindow::MainWindow(QWidget *parent)
           : QMainWindow(parent)
        {
            m_button = new QPushButton("My Button", this);
            connect(m_button, SIGNAL(clicked()), this,
              SLOT(handleButton()));
        }

        void MainWindow::handleButton()
        {
            m_button->setText("Ready");
        }

        #include <QApplication>
        #include "mainwindow.h"

        int main(int argc, char *argv[])
        {
            QApplication app(argc, argv);
            MainWindow mainWindow;
            mainWindow.show();
            return app.exec(d);
        }

        import sys
        from PySide6.QtCore import Slot
        from PySide6.QtWidgets import (
          QApplication, QMainWindow, QPushButton
        )

        class MainWindow(QMainWindow):
            def __init__(self, parent=None):
                QMainWindow.__init__(self, parent)
                self.b = QPushButton("My Button", self)
                self.b.clicked.connect(self.handle_button)

            @Slot()
            def handle_button(self):
                self.b.setText("Ready")

        if __name__ == "__main__":
            app = QApplication(sys.argv)
            mainWindow = MainWindow()
            mainWindow.show()
            sys.exit(app.exec())

• Performance
  • Fast and memory efficient (no runtime or GC).
• Reliability
  • Rich type system and ownership model (mem and thread safety)
• Productivity
  • Docs, friendly compiler, package manager and build tool.

    fn main() {
      println!("Hello, world!");
    }
    

    $ rustc main.rs
    $ ./main
    Hello, world!
    

    #include <iostream>

    using namespace std;

    int main() {
        int nums[] = {1,2,3,4,5,6};
        int five = nums[1] + nums[2];
        cout << "Result: " << five";
    }
    

    fn main() {
        let arr: [i32; 5] = [1, 2, 3, 4, 5];
        let five = arr[1] + arr[2];
        println!("Result: {}", five);
    }
    

    class Person {
      public:
        Person(string n, int a);
        void talk();
        string name;
        int age;
    };
    Person::Person(string n, int a){
        name = n;
        age = a;
    }
    void Person::talk(){
        cout << name << " says Hello!\n";
    }

    int main() {
        Person maria("Maria", 22);
        maria.talk();
    }
    

    // declare a struct
    struct Person {
        name: String,
        age: i32
    }
    impl Person {
        fn speak(&self){
            println!("{} says Hello!",
              self.name);
        }
    }

    fn main() {
        let maria = Person{
          name: String::from("Maria"),
          age: 5
        };
        maria.speak();
    }
    

    #[cxx_qt::bridge]
    pub mod qobject {
      unsafe extern "C++" {
        include!("cxx-qt-lib/qstring.h");
        type QString = cxx_qt_lib::QString;
      }
      unsafe extern "RustQt" {
        #[qobject]
        #[qml_element]
        #[qproperty(i32, number)]
        #[qproperty(QString, string)]
        type MyObject = super::MyObjectRust;
      }
      unsafe extern "RustQt" {
        #[qinvokable]
        fn increment_number(self: Pin<&mut MyObject>);
        #[qinvokable]
        fn say_hi(self: &MyObject,
                  string: &QString,
                  number: i32);
      }
    }
    

Snippet from: github.com/KDAB/cxx-qt/tree/main/examples/qml_minimal

• CXX - safe FFI between Rust and C++
• Idiomatic C++ and Rust
• Macros → Bindings
• Rust threads → update Qt state
• In development

• Memory management (Ownership & Borrowing)
• Quickly evolving

• No hidden control flow, nor memory alloc
• No preprocessor, no macros
• Metaprogramming: compile-time code execution and lazy evaluation (comptime)
• Tests, test, test!

    // main.zig
    const std = @import("std");

    pub fn main() !void {
      const stdout = std.io.getStdOut().writer();
      try stdout.print("Hello, {s}!\n", .{"world"});
    }
    

    $ zig build-exe main.zig
    $ ./hello
    Hello, world!
    

    #include <iostream>
    using namespace std;
    class Rectangle {
      public:
        float x;
        float y;
        Rectangle(float x, float y) :
          x(x), y(y) {}

        float area() {
            return x * y;
        }
    };
    int main(int argc, char *argv[]) {
        Rectangle r = Rectangle(2.2, 3.3);
        cout << "Rectangle area: "
             << r.area();
        return 0;
    }
    

    const std = @import("std");
    const Rectangle = struct {
      x: f32,
      y: f32,
      pub fn init(x: f32, y: f32) Rectangle {
        return Rectangle{
          .x = x, .y = y,
        };
      }
      pub fn area(self: Rectangle) f32 {
          return self.x * self.y;
      }
    };
    pub fn main() !void {
      const r = Rectangle.init(2.2, 3.3);
      const stdout = std.io.getStdOut().writer();
      try stdout.print("Rectangle area: {}\n",
        .{r.area()});
    }
    

  fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
  }
  fn getBiggerFloat(a: f32, b: f32) f32 {
    return max(f32, a, b);
  }
  fn getBiggerInt(a: u64, b: u64) u64 {
    return max(u64, a, b);
  }
  

  // array literal
  const m = [_]u8{ 'h', 'e', 'l', 'l', 'o' };

  // get the size of an array
  comptime {
    assert(m.len == 5);
  }
  

• custom allocators
• Faster and safer than C (*)
• active development

• In development
• Succesor approach
• Interoperability (C++ ⇄ Carbon)
• Modern Generic system
• Safety strategy (Migration plan)

    package hello api;

    fn Main() -> i32 {
      var s: auto = "Hello, world!";
      Print(s);
      return 0;
    }
    

    $ ./explorer hello.carbon
    Hello, world!
    

    // C++
    #include <math.h>
    #include <iostream>
    #include <span>
    #include <vector>

    struct Circle {
      float r;
    }

    void PrintTotalArea(std::span circles) {
      float area = 0;
      for (const Circle& c: circles) {
        area += M_PI * c.r * c.r;
      }
      std::cout << "Total area: " << area << "\n";
    }

    auto main(int argc, char** argv) -> int {
      std::vector circles = {{1.0}, {2.0}};
      // Implicitly converts `vector` to `span`
      PrintTotalArea(circles);
      return 0;
    }
    

    // Carbon
    package Geometry api;

    import Math;

    class Circle {
      var r: f32;
    }

    fn PrintTotalArea(circles: Slice(Circle)) {
      var area: f32 = 0;
      for (c: Circle in circles) {
        area += Math.Pi * c.r * c.r;
      }
      Print("Total area: {0}", area);
    }

    fn Main() -> i32 {
      // A dynamically sized array, like `std::vector`.
      var circles: Array(Circle) = ({.r = 1.0}, {.r = 2.0});
      // Implicitly converts `Array` to `Slice`
      PrintTotalArea(circles);
      return 0;
    }
    

• Simpler syntax
• Safer/modern C++ succesor
• Safety: only way to radically change the std library
• Still experimental

What can we (*) do?

(*) you all, and me

What does it mean to have more languages in Qt?

Q&A

The Role of Language Bindings in the Future of the Qt Ecosystem.

Dr. Cristián Maureira-Fredes
@cmaureir