DEV Community: Santhosh Balasa

Four ISO Standards, One Missing Layer: Trustworthy AI in Financial Services

Santhosh Balasa — Wed, 22 Jul 2026 06:46:57 +0000

If you deploy machine learning in financial services today, you are caught between two moving targets. On one side, the EU AI Act (2024/1689) classifies credit scoring, insurance pricing and several trading applications as high-risk AI, with conformity assessment obligations attached. On the other, the international standards that are supposed to tell you how to comply are still maturing — and, as I'll argue below, they leave a critical layer unspecified.

Over the past three months, as part of a StandICT.eu 2029 fellowship, I have been analysing the four ISO/IEC standards most relevant to trustworthy AI in finance, from the perspective of someone who builds these systems rather than someone who audits them. All of the analysis is public, MIT-licensed, and available in the project repository.

The four building blocks

ISO/IEC 42001 (AI management systems) gives you the governance backbone: accountability, roles, organisational controls. It is genuinely useful if you run a portfolio of AI systems rather than one model. What it does not give you is quantitative reliability thresholds, retraining governance, or anything sector-specific.

ISO/IEC 23894 (AI risk management) frames reliability failures, harm and control breakdowns as risk questions, bridging AI concerns with enterprise risk thinking. But its practical value depends almost entirely on local interpretation — it does not define financial-sector operating thresholds, evidence bundles, or escalation rules.

ISO/IEC 5338 (AI system life cycle processes) structures the engineering lifecycle from development through retirement. Its strongest contribution is process discipline at handoff points — which is where many trust failures in finance actually originate. Its weakest area is live adaptive systems: frequent retraining, vendor model updates, post-deployment revalidation.

ISO/IEC TS 25570 (reliability assessment of AI systems), still under development, is the most directly relevant of the four for live reliability. It elevates reliability into a distinct assurance concern instead of burying it inside generic governance language. But institutions will still need their own operating model for when to reassess and what evidence a continued-use decision requires.

The missing layer

Put the four together and a pattern emerges: governance, risk, lifecycle and reliability are each covered somewhere, but no standard tells a bank or fintech what to do when a live system changes underneath them. Concretely, current standards under-specify:

Concept drift — how to connect drift detection to materiality thresholds, approval triggers and fallback actions, in markets that move faster than validation cycles.
Retraining governance — which retraining events reopen approval conditions, and what evidence each tier requires.
Third-party models — how a vendor's silent model update should re-enter your risk review.
LLM and agentic systems — behaviour change through prompt, retrieval or orchestration changes, none of which look like a classical "new model version".

The implementation problem, in other words, is not choosing the right standard. It is integrating four partial viewpoints into one defensible operational control model.

A proposal: Continuous Reliability Assurance

My fellowship's central technical output is a proposal for Continuous Reliability Assurance (CRA): treating reliability as a continuously supervised control outcome rather than a one-time evaluation result. CRA is not a replacement standard — it is an integration layer that connects the four standards above to live-system supervision, built around three missing pieces:

a trigger taxonomy for reassessment (drift, retraining, vendor update, incident, LLM behaviour change),
a common evidence bundle for continued-use decisions after a live change,
an escalation model linking reliability deterioration to governance action — restriction, rollback, or formal review.

The full proposal, along with a controls gap matrix rating all four standards against ten financial-AI control domains, is in the repository. If you work in model risk, AI governance or ML engineering in finance, I would value your criticism — issues and pull requests are open.

Why this matters for European SMEs

Harmonised, implementable standards are how compliance stops being a legal-interpretation exercise and becomes repeatable engineering. That shift disproportionately benefits smaller firms that cannot staff large compliance teams — provided practitioners are in the room when the standards are written. That is precisely the gap the StandICT.eu programme addresses: it funds European specialists, including SME founders and newcomers to standardisation, to participate in international standards bodies. If you build systems these standards will govern, I recommend applying to a future Open Call.

This work is supported by a StandICT.eu 2029 fellowship, "AI Standardisation for Trustworthy ML Systems in FinTech", funded by the European Commission. Views are the author's own and do not represent StandICT.eu, BSI, ISO, IEC or the European Commission.

[Boost]

Santhosh Balasa — Mon, 09 Mar 2026 17:52:55 +0000

GitHub - yablokolabs/jnaapakam: jñāpakaṁ — An open protocol for AI agent memory persistence. Your AI has a soul now. Don't lose it. · GitHub

jñāpakaṁ — An open protocol for AI agent memory persistence. Your AI has a soul now. Don't lose it. - yablokolabs/jnaapakam

github.com

List of free Quantum Toolkits

Santhosh Balasa — Tue, 10 Dec 2024 20:09:38 +0000

Here is a list of free Quantum Toolkits you can use for Quantum Computing:

Penny Lane: https://pennylane.ai/
Tensorflow Quantum: https://www.tensorflow.org/quantum
Strawberry Fields: https://strawberryfields.ai/
QuTiP: https://qutip.org/
OpenFermion: https://quantumai.google/openfermion
ProjectQ: http://projectq.ch
Qiskit: https://www.ibm.com/quantum/qiskit
TensorNetwork: https://tensornetwork.org

List of free AI Models

Santhosh Balasa — Sat, 11 May 2024 18:15:10 +0000

Here is a list of free AI models you can use for programming:

Chat GPT: https://chatgpt.com/
Mistral AI: https://chat.mistral.ai/
Claude AI: https://claude.ai/
Cohere: https://coral.cohere.com/
Copilot: https://copilot.microsoft.com/
Perplexity AI: https://www.perplexity.ai/
Inflection pi AI: https://pi.ai/
BlackBox AI: https://www.blackbox.ai/
Gemini: https://gemini.google.com/
Phind: https://www.phind.com/
You: https://you.com/
Julius AI: https://julius.ai/
Worm GPT: https://flowgpt.com/chat/wormgpt-6
Poe: https://poe.com/
Meta llama: https://www.meta.ai/
DeepSeek AI: https://chat.deepseek.com/coder
1min AI: https://app.1min.ai/chat-with-ai
Cody: https://sourcegraph.com/cody/chat
Codeium: https://codeium.com/live/general
AI21 Jamba: https://studio.ai21.com/v2/chat
Hugging Face: https://huggingface.co/chat/
Duck AI: https://duck.ai

ClickHouse ReplacingMergeTree Engine: The Airport & Flights Metaphor

Santhosh Balasa — Sat, 07 Oct 2023 18:36:45 +0000

Introduction

To comprehend the inner workings of ClickHouse’s ReplacingMergeTree engine, let’s embark on a journey through an airport’s operations. This metaphorical exploration will elucidate the similarities between the dynamic environment of an airport and ClickHouse’s functionalities.

Passengers & Boarding Passes = Data Entries

• Each data entry in ClickHouse resembles a passenger holding a boarding pass.
• The boarding pass carries essential details, notably a flight number and version.
The Lounge = Temporary Data Storage

• Upon their arrival, passengers settle in the airport lounge, mirroring the initial storage of data in ClickHouse.
• This space hosts first-time travelers and those who have exchanged their initial passes for updated versions.
The Role of the Gate Agent = ReplacingMergeTree Engine

• The gate agent, tasked with verifying boarding passes, ensures passengers with the most recent version for a specific flight board the plane.
• This gate agent’s role mirrors how ClickHouse’s ReplacingMergeTree engine functions — ensuring only the latest version of data is stored, while older versions are seamlessly replaced.
Flight Seating & Merging

• The airplane features various sections. Initially, as passengers board, they might spread across several areas.
• Periodically, the cabin crew reseats passengers to ensure optimal seat utilization, representing the merging aspect of the ReplacingMergeTree engine, where smaller data parts are integrated into larger, more organized segments.
In-flight = Main Data Storage

• Once aboard, passengers represent the consolidated and up-to-date data.
• The meticulous efforts of the gate agent and cabin crew guarantee an organized and efficient flight experience, much like how data is managed in ClickHouse.
Departure & Lounge Management = Efficient Storage Management

• After each boarding call, passengers with outdated boarding passes (older versions of data) are asked to exit the lounge to keep it spacious and organized.
• This process ensures that the lounge remains comfortable and efficient for incoming passengers, just as ClickHouse prioritizes the latest versions of data and efficiently manages storage space.

Conclusion

Navigating through an airport’s bustling operations offers insightful parallels to understanding ClickHouse’s ReplacingMergeTree engine.

The careful management of passengers — from boarding to seating — serves as a fitting metaphor for how ClickHouse seamlessly manages, replaces, and merges data for optimal performance.

Custom Middleware for FastAPI

Santhosh Balasa — Thu, 17 Aug 2023 17:54:39 +0000

This article describes a custom middleware designed for FastAPI applications. The middleware serves several purposes:

Token Authentication: It validates JWT tokens using Azure AD JWKS endpoint, ensuring that the users are authenticated.
Content-Type Handling: It handles the content type of JavaScript files.
Serving UI Files: It serves the UI files and provides a fallback to serve the index.html file for other requests.

Components

Environment Variables

The middleware utilizes the following environment variables:

AZURE_CLIENT_ID: Azure client ID.
AZURE_CLIENT_SECRET: Azure client secret.
AZURE_TENANT_ID: Azure tenant ID.
EXPECTED_AUDIENCE: Expected audience for the JWT token.
EXPECTED_ISSUER: Expected issuer for the JWT token, constructed using the AZURE_TENANT_ID.

Functions

`error_response(error_msg: str, status_code: int) -> JSONResponse`

This function logs the error message and returns a JSONResponse with the error message. It's used for generating standard error responses.

`validate_token(token: str) -> bool`

This function validates a JWT token using the Azure AD JWKS endpoint. It returns True if the token is valid, and False otherwise.

Custom Middleware Class

`class CustomMiddleware(BaseHTTPMiddleware)`

This class contains the core logic of the middleware.

dispatch Method: This method processes the request and sets the content-type header for JavaScript files or serves the index.html file as a fallback for other requests.

Workflow

Token Validation: If the request URL starts with "/api", the middleware checks for an Authorization header and validates the token using the validate_token function.
File Serving: If the request URL doesn't start with "/api", the middleware checks if the requested file exists and serves it with the appropriate content type.
Fallback to index.html: If the requested file is not found, the middleware serves the index.html file.

Code

"""
Custom Middleware for FastAPI Application

This module provides a custom middleware class for FastAPI applications, focused on handling authentication and serving UI files.

- Token Authentication: Validates JWT tokens using the Azure AD JWKS endpoint.
- Content-Type Handling: Manages the content type of JavaScript files.
- Serving UI Files: Serves UI files and provides a fallback to serve the index.html file for other requests.

Environment Variables:
    AZURE_CLIENT_ID: Azure client ID.
    AZURE_CLIENT_SECRET: Azure client secret.
    AZURE_TENANT_ID: Azure tenant ID.
    EXPECTED_AUDIENCE: Expected audience for the JWT token.
    EXPECTED_ISSUER: Expected issuer for the JWT token.

Functions:
    error_response(error_msg: str, status_code: int) -> JSONResponse
    validate_token(token: str) -> bool

Classes:
    CustomMiddleware(BaseHTTPMiddleware): Custom middleware class.

Usage:
    Add the CustomMiddleware class to your FastAPI application's middleware stack.
"""

import os
import jwt
import json
import logging
import requests
import mimetypes


from starlette.requests import Request
from typing import Callable, Coroutine, Any
from starlette.responses import Response, JSONResponse
from starlette.middleware.base import BaseHTTPMiddleware

UI_DIR = "ui/dist"
UI_PATH = "ui/dist/index.html"
AZURE_CLIENT_ID = os.getenv("AZURE_CLIENT_ID")
AZURE_CLIENT_SECRET = os.getenv("AZURE_CLIENT_SECRET")
AZURE_TENANT_ID = os.getenv("AZURE_TENANT_ID")
EXPECTED_AUDIENCE = os.getenv("EXPECTED_AUDIENCE")
EXPECTED_ISSUER = f"https://sts.windows.net/{AZURE_TENANT_ID}/"
logger = logging.getLogger("CustomMiddleware")


def error_response(error_msg: str, status_code: int) -> JSONResponse:
    """
    Logs the error message and returns a JSONResponse with the error message.

    Args:
        error_msg (str): the error message to be logged and returned in the JSONResponse
        status_code (int): the HTTP status code

    Returns:
        JSONResponse: JSONResponse containing the error message
    """
    logger.error(error_msg)
    return JSONResponse(
        content={"error": {"message": error_msg}},
        status_code=status_code,
    )


def validate_token(token: str) -> bool:
    """
    Validate a JWT token using the Azure AD JWKS endpoint.

    Args:
        token (str): The JWT token to be validated.

    Returns:
        bool: True if the token is valid, False otherwise.
    """
    jwks_uri = f"https://login.microsoftonline.com/{AZURE_TENANT_ID}/discovery/v2.0/keys"

    jwks = json.loads(requests.get(jwks_uri).text)
    header = jwt.get_unverified_header(token)

    signing_key = None
    for key in jwks["keys"]:
        if key["kid"] == header["kid"]:
            signing_key = jwt.algorithms.RSAAlgorithm.from_jwk(json.dumps(key))
            break

    if not signing_key:
        return False

    try:
        jwt.decode(
            token,
            signing_key,
            algorithms=["RS256"],
            audience=EXPECTED_AUDIENCE,
            issuer=EXPECTED_ISSUER,
        )
        return True
    except Exception as e:
        logger.error(f"Token validation failed: {e}")
        return False


class CustomMiddleware(BaseHTTPMiddleware):
    """
    Custom middleware for handling content-type of JavaScript files and serving
    index.html as a fallback for other requests.
    """

    async def dispatch(
        self,
        request: Request,
        call_next: Callable[[Request], Coroutine[Any, Any, Response]],
    ) -> Response:
        """
        Process the request and set the content-type header for JavaScript files or
        serve the index.html file as a fallback for other requests.

        Args:
            request (Request): The incoming request.
            call_next (Callable): The next middleware or handler in the stack.

        Returns:
            Response: The generated response.
        """
        logger.debug(f"Request URL path: {request.url.path}")
        if request.url.path.startswith("/api"):
            try:
                if "Authorization" not in request.headers:
                    return error_response("Unauthorized", 401)
                token_header = request.headers["Authorization"]
                if token_header.startswith("Bearer "):
                    token = token_header.split("Bearer ")[-1]
                    if not validate_token(token):
                        return error_response("Unauthorized", 401)
                else:
                    return error_response("Token should begin with Bearer", 400)
            except Exception as e:
                return error_response(f"{e}", 400)
            response = await call_next(request)
            return response

        file_path = os.path.join(UI_DIR, request.url.path.lstrip("/"))

        if os.path.isfile(file_path):
            with open(file_path, "rb") as file:
                content_type, _ = mimetypes.guess_type(file_path)
                return Response(content=file.read(), media_type=content_type)

        response = await call_next(request)
        if response.status_code == 404:
            with open(UI_PATH, "rb") as file:
                return Response(content=file.read(), media_type="text/html")
        return response

Conclusion

This custom middleware provides a unified solution for handling authentication and serving static files in a FastAPI application. The use of JWT for authentication provides security, while the integrated approach to serving static files simplifies the application structure.

ExpiringLRUCache and The CLOCK Algorithm: A Fun Dive into Python Caching

Santhosh Balasa — Mon, 24 Jul 2023 18:36:41 +0000

Introduction

Caching is a common technique that programs use to speed up access to slow data sources by keeping a copy of the data in fast access memory. In Python, we can implement this concept in many ways, but let's talk about an exciting one: The ExpiringLRUCache!

What is ExpiringLRUCache?

ExpiringLRUCache is a cache implementation that combines two powerful concepts: The Least Recently Used (LRU) cache eviction policy and an expiration time for cache entries. In simple terms, it remembers the most recently used items up to a specified limit and for a particular duration. After the duration expires or when the cache is full, it starts removing items, making room for the new ones. Sounds cool, right?

The CLOCK Algorithm

But, how does ExpiringLRUCache decide which item to remove first? Here comes the CLOCK algorithm! It's a smart approximation of the LRU policy. Imagine a clock hand moving over each cache item. If the item is recently used, it gets a "second chance," and the hand moves on. If not, it's time to say goodbye to that item!

How Can We Use ExpiringLRUCache?

Now, let's get our hands dirty with a fun example:

from expiringlrucache import ExpiringLRUCache

# Create a cache of size 3 with items expiring after 60 seconds
cache = ExpiringLRUCache(3, 60)

# Put some items in the cache
cache.put("apple", "delicious")
cache.put("banana", "yummy")
cache.put("cherry", "tasty")

# Get an item from the cache
print(cache.get("banana"))  # Output: "yummy"

# After 60 seconds...
print(cache.get("apple"))  # Output: None (as it's expired)

With just a few lines of code, we've implemented a speedy cache! 🚀

How to Improve It?

Though ExpiringLRUCache is quite efficient, there are a few ways to boost its performance:

Eviction Policy: For more precise LRU behavior, consider implementing a true LRU cache.
Parallelism: If you have a high degree of parallelism, consider partitioning the cache into multiple segments each with its own lock.
Cache Size Tuning: Adjust the cache size based on its observed hit rate.
Dynamic Expiration Strategy: Assign longer expiration times to entries that are accessed more frequently.

Remember, it's all about finding the right balance based on your specific needs!

Conclusion

Caching is a powerful tool, and with Python's flexibility, we can customize it to our heart's content. ExpiringLRUCache and the CLOCK algorithm offer an efficient approach to caching, making our applications faster and more efficient. So, next time you find your program waiting for data, consider using an ExpiringLRUCache. It might just save your day!

Happy caching! 🎉

Decorators in Rust

Santhosh Balasa — Wed, 21 Jun 2023 15:24:07 +0000

Code:

// Define the macro.
macro_rules! log_function {
    ($f:ident($($arg:expr),*)) => {{
        println!("Calling function: {}", stringify!($f));
        $f($($arg),*)
    }};
}

// Some function for demonstration.
fn add(x: i32, y: i32) -> i32 {
    x + y
}

fn main() {
    // Use the macro.
    let result = log_function!(add(5, 7));
    println!("Result: {}", result);
}

Output:

Calling function: add
Result: 12

Rust may not come with built-in support for Python-esque decorators, but that doesn't mean we can't engineer our own! With the might of Rust's macro system at our disposal, we demonstrate how to craft a Python-style decorator using the log_function! macro.

This above inventive piece of code logs function names just before they spring into action. The add function serves as the stage for this cross-linguistic performance, highlighting the extraordinary fusion of Python's elegant simplicity and Rust's high-octane performance within a single, harmonious codebase.

Rust: Embrace the Pythonic Flair with F-String Style!

Santhosh Balasa — Wed, 21 Jun 2023 11:12:05 +0000

In Rust, there is no built-in macro that directly replicates the exact functionality of Python's f-strings, where you can use variable names inside curly braces within the string itself. However, you can define your own macro to achieve a similar result.

Here's an example:

macro_rules! f_string {
    ($($tokens:tt)*) => {
        format!($($tokens)*)
    };
}

fn main() {
    let my_name = "Santee";
    let message = f_string!("{my_name} is cool");
    println!("{}", message);
}

In this example, we define a custom macro called f_string that takes any tokens and passes them directly to the format! macro. The format! macro then performs the string interpolation based on the provided tokens.

You can use the f_string macro to achieve a syntax similar to Python's f-strings, where you enclose the variable name in curly braces directly within the string. However, note that Rust's macro system has different syntax and capabilities compared to Python, so the resulting macro might not provide all the same features or flexibility as Python's f-strings.

Top C++20/23 Features

Santhosh Balasa — Sun, 30 Apr 2023 20:18:40 +0000

1) Coroutines:

Coroutines simplify asynchronous and concurrent programming by allowing functions to be suspended and resumed. They use co_yield, co_await, and co_return keywords.

Example:

#include <iostream>
#include <coroutine>

std::coroutine<int> generator() {
    for (int i = 0; i < 5; ++i) {
        co_yield I;
    }
}

int main() {
    for (int value : generator()) {
        std::cout << value << '\n';
    }
}

2) Ranges:

Ranges provide a more expressive way to work with sequences of values. The new views namespace contains adaptors that allow for lazy evaluation, improving performance and code readability.

Example:

#include <iostream>
#include <ranges>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // Filter even numbers and double their value.
    auto transformed_numbers = numbers | std::views::filter([](int n) { return n % 2 == 0; })
                                       | std::views::transform([](int n) { return n * 2; });

    for (int number : transformed_numbers) {
        std::cout << number << '\n';
    }
}

3) Pattern Matching:

Pattern matching allows for more concise and expressive ways to deal with complex data structures. The inspect keyword is introduced for this purpose.

Example:

#include <iostream>
#include <variant>

using VarType = std::variant<int, double, std::string>;

void print_value(const VarType& var) {
    inspect (var) {
        int x: std::cout << "Integer: " << x << '\n';
        double y: std::cout << "Double: " << y << '\n';
        std::string s: std::cout << "String: " << s << '\n';
    }
}

int main() {
    VarType a = 42;
    VarType b = 3.14;
    VarType c = "Hello, World!";

    print_value(a);
    print_value(b);
    print_value(c);
}

4) Static Exceptions:

Static exceptions are a new way to handle errors without the overhead of traditional C++ exceptions. They use the throws keyword to declare that a function may return an error.

Example:

#include <iostream>
#include <stdexcept>
#include <string>

std::expected<int, std::string> divide(int a, int b) throws {
    if (b == 0) {
        return std::unexpected("division by zero");
    }

    return a / b;
}

int main() {
    auto result = divide(10, 0);
    if (result) {
        std::cout << "Result: " << *result << '\n';
    } else {
        std::cout << "Error: " << result.error() << '\n';
    }
}

5) Concepts and Constraints:

Concepts allow you to specify constraints on template parameters, making the code more readable and producing better error messages during compilation.

Example:

#include <iostream>
#include <concepts>

template<typename T>
concept Numeric = std::is_arithmetic_v<T>;

template<Numeric T>
T add(T a, T b) {
    return a + b;
}

int main() {
    int result = add(1, 2); // This will compile
    // std::string error = add("Hello", "World"); // This will produce a compilation error
    std::cout << result << '\n';
}

6) constinit:

The constinit keyword guarantees that a variable will be initialized during compile time, improving performance by avoiding the need for dynamic initialization.

Example:

#include <iostream>

constinit int compile_time_value = 42;

int main() {
    std::cout << "Value: " << compile_time_value << '\n';
}

7) to_underlying:

The std::to_underlying function simplifies converting an enumeration to its underlying type.

Example:

#include <iostream>
#include <utility>

enum class Color : int {
    Red = 1,
    Green = 2,
    Blue = 3
};

int main() {
    Color c = Color::Red;
    int color_code = std::to_underlying(c);
    std::cout << "Color code: " << color_code << '\n';
}

8) source_location:

The std::source_location class provides a simple way to obtain information about the source code location where it's used, such as file name, line number, and function name.

Example:

#include <iostream>
#include <source_location>

void print_location(const std::source_location& location = std::source_location::current()) {
    std::cout << "File: " << location.file_name() << '\n'
              << "Line: " << location.line() << '\n'
              << "Function: " << location.function_name() << '\n';
}

int main() {
    print_location();
}

9) flat_set and flat_map:

These new containers store elements in a sorted, contiguous memory region, offering better cache locality and faster lookup times compared to std::set and std::map.

Example:

#include <iostream>
#include <flat_set>
#include <string>

int main() {
    std::flat_set<std::string> names = {"Alice", "Bob", "Eve"};

    auto it = names.find("Bob");
    if (it != names.end()) {
        std::cout << "Found: " << *it << '\n';
    }
}

10) simd:

The new std::simd library provides a way to use SIMD (Single Instruction, Multiple Data) operations in C++ programs, allowing for better performance on supported hardware.

Example:

#include <iostream>
#include <algorithm>
#include <execution>
#include <simd>
#include <vector>

int main() {
    std::vector<float> a = {1.0f, 2.0f, 3.0f, 4.0f};
    std::vector<float> b = {5.0f, 6.0f, 7.0f, 8.0f};
    std::vector<float> c(a.size());

    std::transform(std::execution::simd, a.begin(), a.end(), b.begin(), c.begin(), std::plus<float>());

    for (float value : c) {
        std::cout << value << '\n';
    }
}

11) span improvements:

std::span is a non-owning, bounds-safe view over a contiguous sequence of objects. In C++23, new features have been added, such as the ssize function, which returns the size of the span as a signed integer.

Example:

#include <iostream>
#include <span>
#include <vector>

void print_positive_size(const std::span<int>& sp) {
    std::cout << "Size: " << std::ssize(sp) << '\n';
}

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::span<int> num_span(numbers);

    print_positive_size(num_span);
}

12) make_shared:

C++23 adds support for creating std::shared_ptr instances for arrays using std::make_shared.

Example:

#include <iostream>
#include <memory>

int main() {
    auto array_ptr = std::make_shared<int[]>(5);

    for (int i = 0; i < 5; ++i) {
        array_ptr[i] = i;
    }

    for (int i = 0; i < 5; ++i) {
        std::cout << array_ptr[i] << '\n';
    }
}

13) contains:

C++23 adds std::contains to various standard library containers, simplifying the process of checking whether a container contains a specific value.

Example:

#include <iostream>
#include <unordered_set>

int main() {
    std::unordered_set<int> numbers = {1, 2, 3, 4, 5};

    if (numbers.contains(3)) {
        std::cout << "3 is in the set." << '\n';
    }
}

14) erase_if:

C++23 introduces std::erase_if, a utility function to remove elements from a container based on a specific condition.

Example:

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    std::erase_if(numbers, [](int n) { return n % 2 == 0; });

    for (int number : numbers) {
        std::cout << number << ' ';
    }
}

15) chrono improvements:

C++23 introduces new functions and features to the std::chrono library, such as calendar and timezone support.

Example:

#include <iostream>
#include <chrono>
#include <format>

int main() {
    using namespace std::chrono;

    // Get the current time in the system's local timezone
    zoned_time local_time{current_zone(), system_clock::now()};

    // Output the formatted local time
    std::cout << "Local time: " << std::format("{:%Y-%m-%d %H:%M:%S}", local_time) << '\n';
}

16) Lambda improvements:

C++23 introduces improvements to lambda expressions, such as making them more expressive and easier to use.

Example:

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // A lambda with a template parameter
    auto print_value = []<typename T>(const T& value) {
        std::cout << value << ' ';
    };

    std::for_each(numbers.begin(), numbers.end(), print_value);
}

17) net:

C++23 introduces a new networking library, std::net, which provides support for sockets, address resolution, and more.

Example:

#include <iostream>
#include <net>

int main() {
    std::net::ip::tcp::iostream stream("www.example.com", "http");
    if (!stream) {
        std::cerr << "Error: " << stream.error().message() << '\n';
        return 1;
    }

    stream << "GET / HTTP/1.1\r\n"
           << "Host: www.example.com\r\n"
           << "Connection: close\r\n\r\n";
    stream.flush();

    std::string line;
    while (std::getline(stream, line)) {
        std::cout << line << '\n';
    }
}

18) New algorithms in algorithm:

C++23 adds new algorithms to the std::algorithm library, such as shift_left and shift_right, which shift elements within a range.

Example:

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    std::shift_left(numbers.begin(), numbers.end(), 2);

    for (int number : numbers) {
        std::cout << number << ' ';
    }
}

19) identity:

The std::identity function object is introduced in C++23, which can be useful in generic programming as a simple pass-through function.

Example:

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    std::transform(numbers.begin(), numbers.end(), numbers.begin(), std::identity{});

    for (int number : numbers) {
        std::cout << number << ' ';
    }
}

20) bulk_execute:

C++23 adds new functions to the std::execution library, such as std::execution::bulk_execute, which allows you to run a function multiple times concurrently.

Example:

#include <iostream>
#include <execution>
#include <thread>

void print_hello(size_t index) {
    std::cout << "Hello from task " << index << '\n';
}

int main() {
    std::execution::bulk_execute(std::execution::par, print_hello, 10);
}

21) counted_iterator:

C++23 introduces std::counted_iterator, which is useful for creating an iterator that keeps track of a remaining count.

Example:

#include <iostream>
#include <iterator>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    auto start = std::counted_iterator(numbers.begin(), 5);
    auto end = std::default_sentinel;

    for (auto it = start; it != end; ++it) {
        std::cout << *it << ' ';
    }
}

22) default_initializable:

C++23 introduces the std::default_initializable concept, which helps to ensure that a type can be default-initialized.

Example:

#include <iostream>
#include <concepts>

template <std::default_initializable T>
T get_default() {
    return T{};
}

int main() {
    int default_int = get_default<int>();
    std::cout << "Default int: " << default_int << '\n';
}

23) starts_with and ends_with:

C++23 adds starts_with and ends_with member functions to std::basic_string, making it easier to check if a string starts or ends with a specific substring or character.

Example:

#include <iostream>
#include <string>

int main() {
    std::string greeting = "Hello, world!";

    if (greeting.starts_with("Hello")) {
        std::cout << "The greeting starts with 'Hello'." << '\n';
    }

    if (greeting.ends_with('!')) {
        std::cout << "The greeting ends with an exclamation mark." << '\n';
    }
}

24) is_scoped_enum:

C++23 adds the std::is_scoped_enum type trait, which helps determine if a given type is a scoped enumeration (i.e., an enum class).

Example:

#include <iostream>
#include <type_traits>

enum class ScopedEnum { A, B, C };
enum UnscopedEnum { X, Y, Z };

int main() {
    std::cout << std::boolalpha
              << "ScopedEnum is scoped: " << std::is_scoped_enum_v<ScopedEnum> << '\n'
              << "UnscopedEnum is scoped: " << std::is_scoped_enum_v<UnscopedEnum> << '\n';
}

25) chunk:

C++23 introduces std::views::chunk, which allows you to create a view that groups elements in a range into subranges of a specified size.

Example:

#include <iostream>
#include <vector>
#include <ranges>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    auto chunked_view = numbers | std::views::chunk(3);

    for (const auto& chunk : chunked_view) {
        for (int number : chunk) {
            std::cout << number << ' ';
        }
        std::cout << '\n';
    }
}

26) unwrap_reference:

C++23 introduces std::unwrap_reference, a utility to unwrap reference_wrapper instances and leave other types unchanged.

Example:

#include <iostream>
#include <functional>
#include <type_traits>

int main() {
    int value = 42;
    std::reference_wrapper<int> ref_wrapper(value);

    // Unwrap reference_wrapper
    auto& unwrapped_ref = std::unwrap_reference(ref_wrapper);

    // Modify the original value through the unwrapped reference
    unwrapped_ref = 55;

    std::cout << "Original value: " << value << '\n';
}

27) copyable and movable:

C++23 introduces the std::copyable and std::movable concepts, which help ensure that a type is copyable or movable, respectively.

Example:

#include <iostream>
#include <concepts>

template <std::copyable T>
void process_copyable(const T& obj) {
    // Process obj
}

template <std::movable T>
void process_movable(T&& obj) {
    // Process obj
}

int main() {
    int value = 42;
    process_copyable(value); // OK, int is copyable
    process_movable(std::move(value)); // OK, int is movable
}

28) polymorphic_allocator improvements:

C++23 enhances std::polymorphic_allocator with additional features, such as support for array allocations.

Example:

#include <iostream>
#include <memory_resource>
#include <vector>

int main() {
    std::pmr::unsynchronized_pool_resource pool;
    std::pmr::polymorphic_allocator<int> alloc(&pool);

    std::pmr::vector<int> numbers(alloc);
    numbers.reserve(10);
    for (int i = 1; i <= 10; ++i) {
        numbers.push_back(i);
    }

    for (int number : numbers) {
        std::cout << number << ' ';
    }
}

29) dynamic_extent:

C++23 introduces std::dynamic_extent, which is a constant that represents a dynamic extent for span and mdspan.

Example:

#include <iostream>
#include <span>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    std::span<int, std::dynamic_extent> dynamic_span(numbers);

    for (int number : dynamic_span) {
        std::cout << number << ' ';
    }
}

30) to_underlying:

C++23 introduces std::to_underlying, a utility function that makes it easier to convert an enumeration value to its underlying integral type.

Example:

#include <iostream>
#include <type_traits>

enum class Color : int { Red, Green, Blue };

int main() {
    Color color = Color::Red;

    auto underlying_value = std::to_underlying(color);

    std::cout << "Color::Red has an underlying value of: " << underlying_value << '\n';
}

Merge Command

Santhosh Balasa — Tue, 25 Oct 2022 17:06:48 +0000

Have you come across a situation where you have a very huge table Eg: 100 million rows and you need to update the deltas ?

Y'all probably re-create the whole table to cater such a situation, well now you do not have to fret about it, we have merge command released in Postgres 15.

Example:

create table demo (id serial primary key, val int);

inset into demo (val) select x * 10 from generate_series(1, 10) as x;

create table demo1 as (select id, id * 100 as val
 from 
generate_series(1, 10, 2) as id) ;

select * from demo order by id;
select * from demo1;

merge
into demo as d
       using demo1 as d1
on
   d.id = d1.id
   when matched then
update
set
   val = d1.val
   when not matched then
insert 
   (val)
values (d1.val) ;

select * from demo order by id;

Viola ! Easy peasy now !

Inverting a Binary Tree

Santhosh Balasa — Thu, 23 Dec 2021 11:06:41 +0000

Binary Tree:

         (4)
        /  \
       /    \
     (2)    (7)                  
     / \    /  \
    /   \ (6)  (9)
  (1)   (3)

Inverting a Binary tree means mirroring the tree, i.e, swapping the children from left to right and vice versa.

Inverted Binary Tree:

         (4)                         
        /  \
       /    \
     (7)    (2)                    
     / \    /  \
    /   \ (3)  (1)
  (9)   (6)

This can be easily achieved using recursion,

Code:

tree = {
    4: [2, 7],
    2: [1, 3],
    7: [6, 9],
    1: [],
    3: [],
    6: [],
    9: []
}


def invert_tree(tree, node, path=[]):
    if tree[node]:
        path.extend(tree[node][::-1])
        invert_tree(tree, tree[node][1], path)
        invert_tree(tree, tree[node][0], path)
    return [node] + path