eigengrau

Eigengrau is a near-black shade with subtle indigo and violet undertones. Because it sits at the edge of visibility, the hex code #16161d works better as a screen background than pure black, offering higher readability and less eye strain. It pairs effectively with soft, muted neons or stark whites. Designers favor this color for moody UI interfaces where a softer, more grounded alternative to absolute black is required.

source: https://colorkit.co/color/16161d/

Eigengrau is a German loanword used to describe the specific color of total darkness as perceived by human eyes. Rather than black, the color that human optic nerves discern in pure darkness is a dark gray. In German, eigengrau translates to “intrinsic gray”.

source: https://worddaily.com/words/eigengrau/

Medallion architecture: bronze, silver, and gold

 A layered data organization system:

• Bronze: Raw, unprocessed data as it arrives from source systems. Preserves original state for auditing and reprocessing.
• Silver: Cleaned, deduplicated, and standardized data. Conforms to consistent naming and formatting conventions across the organization.
• Gold: Business-ready, curated datasets optimized for analytics and reporting. This is where data becomes actionable for business users.

This three-tier structure moves data from its raw form through progressive refinement, improving quality and usability at each stage.

See related TWOTW: ETL - extract, translate, load

Sources:

• Medallion Architecture: Bronze, Silver & Gold Layers Explained (2026 Guide)
• Data Lake Zones: Bronze, Silver, Gold Architecture | Conduktor
• Understanding the Three Layers of Medallion Architecture

footgun (slang)

A footgun is a slang term for a design feature, tool, or piece of code that allows or encourages users to accidentally cause self-harm or make severe mistakes. It is a metaphor for a gun designed in such a way that you easily shoot yourself in the foot.

Key Characteristics

Not a bug: The system works exactly as intended and written, but the design is dangerous or counter-intuitive.

Blames design, not user: It highlights a flaw in how a tool is structured rather than calling the user foolish.

Common in programming: Frequently used to describe confusing APIs, overly permissive settings, or dangerous syntax.

source: AI overview

Similar: pitfall, pothole, landmine, boobytrap (though not normally intentional or malicious)

SPACE framework metrics

The SPACE framework is a research-backed model for measuring software engineering productivity across five key dimensions: 

• Satisfaction/well-being
• Performance
• Activity
• Communication/collaboration
• Efficiency/flow

Developed by researchers from Microsoft and GitHub, it avoids traditional output-only metrics in favor of a holistic approach.

The Five Dimensions of SPACE Metrics

S - Satisfaction and well-being: How developers feel about their work environment, team dynamics, and health. This is measured through surveys, burnout signals, eNPS, and retention rates.

P - Performance: The outcomes and impact of development efforts rather than just the code produced. Key indicators include customer-reported defects, service reliability, and change failure rates.

A - Activity: The volume or count of actions performed within the development process. It tracks commits, pull requests, code reviews, and build completions, though it should be balanced with other dimensions to prevent misleading output measurements.

C - Communication and collaboration: How teams work together and share knowledge. This evaluates the quality of code reviews, documentation, and the clarity of communication across distributed teams.

E - Efficiency and flow: The ability to complete tasks with minimal interruptions and delays. Measurements focus on cycle times, deployment frequency, focused development time, and the speed at which code is merged.

source: AI overview

DORA metrics

DORA metrics are standardized key performance indicators developed by Google's DevOps Research and Assessment team to measure software delivery speed and stability. Engineering teams use them to identify bottlenecks, balance velocity with quality, and benchmark their delivery maturity against industry standards.

The Core DORA Metrics

The four primary metrics are divided into two categories:

Velocity & Throughput

• Deployment Frequency (DF): How often code is successfully released to production (e.g., multiple times a day vs. once a month).
• Lead Time for Changes (LT): The time it takes for a commit to travel from the beginning of the development cycle to production deployment.

Stability & Reliability

• Change Failure Rate (CFR): The percentage of deployments that cause a production failure and require immediate remediation.
• Mean Time to Recover (MTTR): The average time it takes an organization to restore service after a production failure or incident.

source: AI overview

Further reading: https://dora.dev/guides/dora-metrics/

PKCE (pronounced "pixy")

RFC 7636: Proof Key for Code Exchange

www.rfc-editor.org/rfc/rfc7636

PKCE (RFC 7636) is an extension to the Authorization Code flow to prevent CSRF (cross-site request forgery) and authorization code injection attacks.

PKCE was originally designed to protect the authorization code flow in mobile apps, but its ability to prevent authorization code injection makes it useful for every type of OAuth client, even web apps that use client authentication.

source: https://oauth.net/2/pkce/

AI Overview

How It Works

PKCE replaces the need for a client secret with a cryptographic proof process:

1. Create the Verifier: The client app generates a cryptographically random, high-entropy string called the Code Verifier.
2. Create the Challenge: The app hashes this string (typically using SHA-256) to create the Code Challenge.
3. Send the Challenge: The app sends the Code Challenge to the authorization server alongside the initial login request.
4. Exchange and Verify: When the authorization server returns the authorization code, the app sends the code plus the original unhashed Code Verifier back to the server. The server hashes the provided verifier and confirms it matches the original challenge before issuing an access token.

poka-yoke, forcing function

Poka-yoke is a Japanese term that means "mistake-proofing" or "error prevention", and is also sometimes referred to as a forcing function or a behavior-shaping constraint.

Defects occur when the human mistakes are allowed to reach the customer. The aim of poka-yoke is to design the process so that mistakes can be detected and corrected immediately, eliminating defects at the source.

Poka-yoke was originally baka-yoke, which means "fool-proofing" (or "idiot-proofing").

source: https://en.wikipedia.org/wiki/Poka-yoke

Forcing functions are a super way to help make things foolproof, or better, errorproof — as all of us make mistakes with designed things without being fools. You may have used your own forcing function when, in an attempt to make sure you remember your passport or tickets before a flight, you put them directly in front of the door so you couldn’t open it without noticing them.

source: https://sketchplanations.com/forcing-function

RAG pipeline

A Retrieval-Augmented Generation (RAG) pipeline enhances Large Language Model (LLM) outputs by fetching relevant data from external sources, reducing hallucinations and improving accuracy. It involves indexing documents into a vector database, retrieving relevant chunks based on user queries, and augmenting the prompt with this context to generate grounded responses.

How a RAG Pipeline Works

The RAG pipeline operates through two main phases: ingestion (preparing knowledge) and retrieval (generating answers). 

1. Data Ingestion & Indexing: Documents (PDFs, websites, databases) are loaded, split into smaller chunks, converted into numerical embeddings via an AI model, and stored in a vector database.
2. Retrieval & Generation: A user query is converted into a vector and matched against the vector database to find the most relevant chunks. These chunks, along with the original question, are fed to the LLM to generate a precise answer. 

cit.: YouTube

Benefits of RAG Pipelines

• Reduced Hallucinations: Grounding answers in provided documents ensures higher factual accuracy.
• Up-to-Date Information: Enables models to access, for example, the latest internal documents without retraining.
• Data Privacy: Allows querying private or proprietary data sources securely. 

cit.: NVIDIA Developer

How to Build a RAG Pipeline

Building a RAG pipeline typically involves these steps:

1. Load Data: Use loaders for files, websites, or databases.
2. Chunking: Divide data into smaller, manageable text sections.
3. Embeddings & Storage: Use embedding models to vectorize text and store them in a vector store like Pinecone, ChromaDB, or Weaviate.
4. Retrieval Engine: Build a mechanism to perform semantic searches for relevant info.
5. LLM Generation: Send retrieved content to a model (like GPT-4) to generate the answer.
6. Frameworks: Utilize frameworks like LangChain or LlamaIndex to connect these components. 

cit.: YouTube

source: AI summary

reference: https://developer.nvidia.com/blog/rag-101-demystifying-retrieval-augmented-generation-pipelines/

Semantic Kernel

Semantic Kernel is a lightweight, open-source development kit that lets you easily build AI agents and integrate the latest AI models into your C#, Python, or Java codebase. It serves as an efficient middleware that enables rapid delivery of enterprise-grade solutions, backed with security enhancing capabilities like telemetry support.

Semantic Kernel combines prompts with existing APIs to perform actions. By describing your existing code to AI models, they’ll be called to address requests. When a request is made the model calls a function, and Semantic Kernel is the middleware translating the model's request to a function call and passes the results back to the model.

source: https://learn.microsoft.com/en-us/semantic-kernel/overview/

LDAP (Lightweight Directory Access Protocol)

LDAP, the Lightweight Directory Access Protocol, is a mechanism for interacting with directory servers. It’s often used for authentication and storing information about users, groups, and applications.

source: https://ldap.com/

The Lightweight Directory Access Protocol (LDAP) is a directory service protocol that runs on a layer above the TCP/IP stack. It provides a mechanism used to connect to, search, and modify Internet directories. The LDAP directory service is based on a client-server model. The function of LDAP is to enable access to an existing directory.

source: https://learn.microsoft.com/en-us/previous-versions/windows/desktop/ldap/lightweight-directory-access-protocol-ldap-api