Skip to content

Blogs

  • The Abstract Factory Pattern in Python: Families of Things That Belong Together

    The Abstract Factory pattern takes the Factory pattern one step further. Instead of creating one object, it creates a whole family of related objects that are guaranteed to work together. In this post we use a cross-platform notification system (mobile, web, and desktop) to show why a regular factory isn’t always enough, how Abstract Factory…

  • The Observer Pattern in Python: Don’t Call Us, We’ll Call You

    The Observer pattern lets objects subscribe to events and get notified automatically when something changes — no polling, no tight coupling. In this post we use a real-time stock price alert system to show why hardcoded notification logic breaks down, how to fix it with observers, how it compares to the Factory pattern, and where…

  • The Factory Pattern in Python: Let Someone Else Decide What to Build

    The Factory pattern lets your code create objects without hardcoding which class gets instantiated — making it easy to swap implementations without touching the rest of your app. In this post, we use a real-world notification system (email, SMS, push) to show the before/after, cover the function-based alternative, discuss how Factory and Singleton work together,…

  • The Singleton Pattern in Python: One Instance to Rule Them All

    The Singleton pattern guarantees a class or function to only ever creates one instance, no matter how many times you call it. In this post, we break down why that matters for Python developers using SQLAlchemy, show you both a class-based and function-based implementation, and cover thread safety, the GIL, and where else singletons show…

  • How Python Reads Your Code: AST Explained Using a Data Contract Framework

    Before Python executes your code, it transforms it into an Abstract Syntax Tree (AST). In this article, we’ll explore how AST works, how Python understands source code, and how we can use it to detect schema changes in a data contract framework.

  • Metaclasses in Python: Understanding the Factory That Builds Your Classes

    Most Python developers create classes every day without realizing that classes themselves are objects. This article explains metaclasses through simple analogies and demonstrates how they can be used to build powerful frameworks and automation tools.

  • What Is a Schema? The Blueprint Behind Every Data Pipeline

    What exactly is a schema, and why do data engineers care so much about them? Learn how schemas act as contracts between systems and why even a small change can break entire data pipelines.

  • Building a Plugin-Based Validation Engine in Python

    How to validate, introspect, and safely load user-defined Python code with a real plugin engine as the example.

  • The Heartbeat of the Market: A Friendly Guide to Implied and Local Volatility

    This blog post explains why the standard “speed limit” (Black-Scholes) fails to predict market crashes, leading to the “Volatility Smirk” driven by investor fear. It clarifies the difference between Implied Volatility (your average trip speed) and Local Volatility (your speedometer’s exact wiggle at a specific price), stripping away the math jargon to reveal the human…

  • The “Smart” Committee: Scaling Option Pricing with k-Sparse Gated Neural Networks

    A single neural network often struggles to price options accurately across every regime. Why ask a LEAPS expert to price a 0DTE call? k-Sparse Gating solves this by acting as an intelligent ‘triage’ system. By activating only the Top-k specialists from a committee of 9 regime-trained experts, we eliminate ‘model noise’ and slash GPU latency.…

  • Beyond Correlation: Are Your Stocks Cointegrated or Just Casual?

    We’ve all seen stocks that seem to move in sync, but how do you know if that relationship is built to last? Simple correlation can be a mirage, leading you into ‘Value Traps’ and failed pairs trades. In this blog, we explore Cointegration and Granger Causality—the two statistical powerhouses that reveal which stocks are permanently…

  • Prewhitening vs. Differencings: Why Cleaning Isn’t Enough

    Spurious correlations can fool even experienced traders. Two stocks may appear to move in perfect sync, but the relationship often comes from shared market trends rather than any real influence between them. This blog focuses on how to uncover those false signals. By applying prewhitening, we remove the common market noise and isolate the true…

  • Why You Need Prewhitening for Time Series

    In this blog we explore what spurious correlation is and how prewhitening can be used to eliminate such mistakes in our analysis of time series data. This is most important for people who wants to see cross correlation relationships between two time series.

  • My Story

    I’ve always been fascinated by how data can be architected to solve complex problems. This single passion has guided my entire journey.