A Byte of Coding Issue 397

Hey-yo,

Hope you had a nice weekend. Below are the results of the survey. The winner was 2025 (across linkedin and twitter as well), so we’ll see fairly soon if the majority are correct. A couple of subscribers also wrote text comments.

bediger selected “Never” and said “Llms will turn out to be unreliable, fibbing or hallucinating unpredictably.” I’m sure with the current architecture LLMs will always be unreliable to some extent, but I’d say they’re already at a useful enough level that would justify integration. Spell check isn’t perfect but it’s built into most systems.

janar selected “Never” and said “It's more of a hope than a certainty, that it will be never. Some rumors were saying that Apple is doing some AI stuff. Wouldn't be surprised if in just a couple of weeks they announce some local LLM.” An optimist, but a realist too. I think energy would be better spent thinking of how to improve existence with LLMs over struggling against them.

tom selected “2025” and said “I think Apple will do this by the new year, given Corenet. It will be followed by Windows probably late '25.” CoreNet does look like a strong signal! We now have two voting for Apple as first to integrate (quite appropriate since this was published a couple of days ago).

msmetko selected “2025” and said “I like turtles” Who doesn’t?!

Made possible through generous sponsorship by:

The Notifier Pattern for Applications That Use Postgres

Published: 6 May 2024

Tags: postgres, database

Brandur Leach discusses the notifier pattern, which optimizes the use of Postgres connections in applications by maintaining a single connection for multiple notifications, enhancing efficiency and reducing overhead.

Some highlights:

• The notifier pattern conserves PostgreSQL connections by allowing multiple components to listen on a single connection for notifications.

• Implementation details include handling subscription overlap and ensuring that notifications continue even if one component fails to process them immediately.

• The system's design includes "interruptible receives" and a robust error handling strategy, adopting a "let it crash" philosophy for maximum resilience.

A High-Level Technical Overview of Fully Homomorphic Encryption

Published: 4 May 2024

Tags: math, crypto

Jeremy Kun provides a technical overview of Fully Homomorphic Encryption (FHE), explaining its principles and potential applications in securing computations on encrypted data without decryption.

Some highlights:

• FHE allows computations on encrypted data, ensuring the data remains secure even during processing.

• Discusses the technical challenges and current limitations of FHE, such as performance issues and the complexity of noise management.

• Explores several encryption schemes, highlighting their mechanics and use in practical applications.

SQLite Optimizations for Ultra High-Performance

Published: 25 May 2023

Tags: sponsored, database, sqlite, optimization

PowerSync outlines techniques for optimizing SQLite databases to achieve ultra-high performance, focusing on practical settings and programming strategies to enhance efficiency.

Some highlights:

• Introduces the concept of Write-Ahead Logging (WAL) to significantly decrease transaction times by reducing the overhead associated with disk writes.

• Discusses optimizing data binding and transaction handling to boost SQLite's performance in application environments.

• Highlights the use of prepared statements and JSON1 functions to increase database operation speed and decrease coding complexity.

What is in a Rust Allocator?

Published: 6 May 2024

Tags: rust

Robin Schroer explains the intricacies of designing a custom memory allocator in Rust, including the use of atomic operations and alignment practices to manage memory efficiently.

Some highlights:

• The allocator uses an UnsafeCell with a fixed size arena and an atomic counter for managing memory allocations efficiently.

• Discusses the Rust language’s support for memory alignment and atomic operations to ensure thread safety and operational correctness.

• Outlines a simple allocator implementation using the #[global_allocator] macro to designate a custom global allocator in Rust applications.