Programming Leftovers and Kernel Work

posted by Roy Schestowitz on Apr 13, 2024

• Mozilla ☛ Hacks.Mozilla.Org: Prototype even faster with the Gradio UI for Figma component library

  As an industry, generative Hey Hi (AI) is moving quickly, and so requires teams exploring new ideas and technologies to move quickly as well. To do so, we have been using Gradio, a low-code prototyping toolkit from Hugging Face, to spin up experiments and experiences. Gradio has allowed us to validate concepts through prototyping without large investments of time, effort, or infrastructure.

• Chris ☛ Browser-Based XmR Charts

• Qt ☛ Qt for MCUs 2.5.3 LTS Released

  As a patch release, Qt for MCUs 2.5.3 LTS provides bug fixes and other improvements, and maintains source compatibility with Qt for MCUs 2.5.x. It does not add any new functionality.

• KDAB ☛ Recursive Instantiation with Qt Quick and JSON

  Recently I was tasked to come up with an architecture for remote real time instantiation and updating of arbitrary QML components.

  This entry shows how you can use a simple variation of the factory method pattern in QML for instantiating arbitrary components. I’ve split my findings into 3 blog entries, each one covering a slightly different topic. Part 1 focuses on the software design pattern used to dynamically instantiate components. Part 2 shows how to layout these dynamic components by incorporating QML’ s positioning and layout APIs. The last entry, consisting of Parts 3 and 4, addresses the anchors API and important safety aspects.

  This is Part 1: Recursive Instantiation with Qt Quick and JSON.

  The original factory method pattern made use of static methods to programmatically instantiate objects of different classes, instead of having to call their constructors. It achieved that by having the classes share a common ancestor. Our variation of the popular pattern uses a Loader to choose which component to load, and a Repeater to dynamically instantiate arbitrary instances of this loader using a model.

  Here we specify which components with a JSON array and use a Repeater to load them.

• Rlang ☛ simaerep release 0.5.0

  Simulate adverse event reporting in clinical trials with the goal of detecting under-reporting sites.
  Monitoring of Adverse Event (AE) reporting in clinical trials is important for patient safety.

• Net2 ☛ 7 Signs of a Good Bug Report

  Every software or website developer is no stranger to bug reports.

• LWN ☛ Radicle: peer-to-peer collaboration with Git

  Radicle is a new, peer-to-peer, MIT/Apache-licensed collaboration platform written in Rust and built on top of Git. It adds support for issues and pull requests (which Radicle calls "patches") on top of core Git, which are stored in the Git repository itself. Unlike GitHub, GitLab, and similar forges, Radicle is distributed; it doesn't rely on having everyone use the same server. Instead, Radicle instances form a network that synchronizes changes between nodes.

  As a new project, Radicle is not fully featured compared to the mature and centralized forges. That said, the Radicle developers are using Radicle itself to collaborate on the software, along with a Zulip chat system. The first 1.0.0 release candidate was announced on March 26.

• Kernel Space

  • LWN ☛ Improving performance with SCHED_EXT and IOCost

    At SCALE this year Dan Schatzberg and Tejun Heo, both from Meta, gave back-to-back talks about some of the performance-engineering work that they do there. Schatzberg presented on the extensible BPF scheduler, which has been discussed extensively on the kernel mailing list. Heo presented on IOCost — a control group (cgroup) I/O controller optimized for solid-state disks (SSDs) — and the benchmark suite that is necessary to make it work well on different models of disk.

  • LWN ☛ A memory model for Rust code in the kernel

    The Rust programming language differs from C in many ways; those differences tend to be what users admire in the language. But those differences can also lead to an impedance mismatch when Rust code is integrated into a C-dominated system, and it can be even worse in the kernel, which is not a typical C program. Memory models are a case in point. A programming language's view of memory is sufficiently fundamental and arcane that many developers never have to learn much about it. It is hard to maintain that sort of blissful ignorance while working in the kernel, though, so a recent discussion of how to choose a memory model for kernel code in Rust is of interest.