Travis Bikkle's Technical Blog

Semi-synchronous replication is an alternative to asynchronous replication that reduces the risk of data loss during failover.

How it works:

1. The master waits for at least one semi-synchronous slave to acknowledge that the transaction's binary log events have been received and written to the slave's relay log.
2. The master only commits the transaction after receiving this acknowledgment or after a timeout occurs.
3. If the timeout is reached without acknowledgment, the master reverts to asynchronous mode.
4. The master automatically switches back to semi-synchronous mode once a slave catches up.

Requirement: Semi-synchronous replication must be enabled on both the master and the slave; otherwise, the system defaults to asynchronous replication.

A Kubernetes Operator is an extension used to manage Custom Resources (CRs) by implementing a 'control loop'. The control loop continuously monitors the current state of a resource and reconciles it to match the desired state defined by the user in a declarative API.

Key components include:

• Custom Resource (CR): A user-defined object (e.g., DatabaseUser) that specifies the desired state.
• Custom Resource Definition (CRD): The schema/description file that tells Kubernetes the type and details of the Custom Resource so the Operator knows what to monitor.
• Controller: The actual code running within the Operator process that handles create, update, and delete events for a specific Kind of resource.

Unlike languages that use Garbage Collection (GC) to prevent memory errors, Rust uses an ownership system checked at compile time. This prevents common dynamic memory errors such as:

• Use-after-free: Attempting to use a variable after it has been deallocated.
• Double-free: Releasing the same memory address twice.

In Rust, Box<T> is the primary type for heap allocation. It allocates memory via Box::new and automatically deallocates it via the Drop trait. The compiler ensures that no references (borrows) to the heap data exist after the owner of the Box is dropped, eliminating the need for runtime GC overhead.

The Implicit flow (response_type=token) is designed for clients without a backend (e.g., pure frontend browser applications). Unlike the Authorization Code flow, it skips the authorization code step and returns the token directly to the client after user consent.

Caveats:

• The AS does not validate the client in the same way as other flows.
• Tokens are often transmitted in the URI fragment (e.g., redirect.com/callback#token=xxx), making them potentially visible to the Resource Owner or other programs with access to the user agent.

To ensure security and isolate program memory, x86 architectures use paging. Paging divides both virtual and physical memory into small, fixed-size blocks.

• Page: A fixed-size block in virtual memory.
• Frame: A fixed-size block in physical memory.
• Page Table: The data structure that stores the mapping between virtual pages and physical frames.