Experiments and engineering notes from the age of AI
-
Breadcrumbs
I asked ChatGPT a stupid question a few months ago.
-
The Story Point That Was Never About Time
I opened Jira.
-
The Plastic Code
It starts quietly.
-
The C# You Don't Know
It started with a single keyword.
-
OpenMP: The 90s Parallelism That Never Left
You spend an undergraduate semester writing
#pragma omp parallel foron a Sun UltraSPARC, thinking it’s a relic you’ll never touch again. Twenty-five years later, you’re deploying ONNX Runtime on Linux — and OpenMP is still there, quietly running half the numerical world. -
SQL, Extensibility, and the Democratization of Infrastructure
We started with a graph database. It made sense on paper — codebases are graphs of symbols and dependencies, so query them through a graph traversal API. We built a custom query layer over the dependency graph:
GetDownstreamDependents(symbol, depth),FindCycles(component),TracePath(source, target). Clean abstractions. Clear semantics. -
From Files to Structured Intelligence
A codebase is not a text file collection. It is a graph of symbols, relationships, and semantics — but most tools never extract that structure. They search text. They grep. They match patterns against string content, not against meaning.
-
Transform Repositories into Queryable Intelligence
Why the next frontier in AI-assisted engineering isn’t better code generation — it’s repository cognition.
-
Memori: Enterprise Patterns and Incremental Adoption
The hardest part of adding memory to an AI app is not the first turn. It is turn 10,000 with two data centers, three storage backends, and a compliance requirement.
-
Memori: Storage, Recall, and the Middleware Pipeline
A memory library’s job is not to store everything. It is to store the right things and retrieve the relevant things.
-
Durable Memory for .NET AI Applications
Semantic Kernel had memory. It had RAG concepts, conversation history plugins, vector store integrations — all the ingredients. But it was heavy. Gravitational. You didn’t bolt on Semantic Kernel; you migrated into its orbit. Everything was our way or nothing.
-
The Structural Problems
Part 1 addressed the productivity illusion — the measurement bias, the hidden value of friction, the greenfield conditions that make the numbers look good. This part addresses the structural problems that emerge at scale: the review bottleneck that agents make dramatically worse, the hard limits of agent capability on real codebases, and the vast category of enterprise software that the productivity conversation has ignored almost entirely.
-
The Productivity Illusion
There is a version of the AI-in-engineering story that is true. Agents write code faster than humans. Certain categories of work that took days now take hours. Some teams are shipping more with fewer people. That part is real.
-
C# Dev Exploring Java: The Effective Java Effect (Part 6)
Every difference in Parts 1-5 shares a common thread. Not age. Not design by committee. Something else — a book that became a blueprint for an entire ecosystem.
-
C# Dev Exploring Java: Data & Async — The Twin Shocks (Part 5)
Two areas where the C# mental model actively hurts you: data processing and concurrency. They’re unrelated in topic but share a theme — C# built them into the language, Java bolted them on as libraries.
-
C# Dev Exploring Java: Generics, But Not Really (Part 4)
Java’s type system was designed in 1995. C# had a second chance. This single difference affects every library, every framework, and every generic class you write.
-
C# Dev Exploring Java: How Do I Say That? (Part 3)
C# has over a dozen language features for concise API design. Java has fewer — and the gap shapes entire ecosystems. This is the biggest culture shock you’ll feel.
-
C# Dev Exploring Java: No Safety Net (Part 2)
C# wraps things in sugar. Java makes you see the machinery. This part covers what Java doesn’t protect you from — null, exceptions, and how values work.
-
C# Dev Exploring Java: Wait, It Does That? (Part 1)
You open IntelliJ, write your first Java class, and the compiler laughs at you. These are the day-one surprises — things that break within the first hour of writing Java.
-
Backpressure, Interop, and Streaming ASP.NET Core Responses With Streamix
The easiest way to make a streaming library sound impressive is to talk only about composition.
-
Hot vs Cold Streams, Ordering, and Async Composition in Streamix
Most streaming abstractions become hard to trust at the exact point where they become operationally interesting.
-
Streamix: The Core Mental Model
If Streamix is going to be useful, the mental model has to be simple.
-
Streamix: A Stream Library for Modern .NET
Modern .NET already gives us serious async building blocks.
-
Stillness in Motion: Change as a Sign of Createdness
The Quran highlights the cycle of life and constant change as clear, observable signs of divine wisdom and a reminder of deeper truths. Among these, the day and night cycle is presented as one of the most vivid and universal examples.
-
Stop Orchestrating Workflows in the Browser
Most teams get this wrong once: they try to orchestrate long-running workflows from the UI, chaining REST calls and painting progress bars in JavaScript. It works in demos, then breaks in production. Lets take the opposite path: backend-owned orchestration with simple .NET building blocks (
Channel,BackgroundService) and SignalR for live progress. -
Concurrency, Reimagined: From CSP to Erlang, Go, .NET — and Even Vue
Concurrency is one of those topics where theory sounds clean… until you open a production system and see threads, locks, retries, and “temporary” fixes everywhere.
-
Respect Time
As engineers, we care a lot about efficiency. But strangely, one of the biggest sources of waste in our day-to-day doesn’t come from bad code or slow pipelines… it comes from unclear work. Starting a ticket that isn’t ready creates invisible waste—ping-ponging between Product, Development, and QA.
-
Symbolics: Unleashing the Power of Symbolic Computation in Engineering
The Math.NET Symbolics library does have a certain elegance, much like LINQ. Symbolic computation feels almost magical because it allows us to manipulate mathematical expressions in their symbolic form, rather than just crunching numbers. It brings abstract algebraic concepts into the digital realm, enabling tasks like simplification, differentiation, or even equation solving.
-
ScrumUpdate Deep Dive
This post contains the deep-dive technical details and implementation notes. It documents the architecture, data model, key service implementations, testing approach, and a production-readiness checklist.
-
From Theory to Practice: Implementing Blackboard Architecture in Modern Blazor Apps
In Part 1, we explored Blackboard Architecture—a classic AI problem-solving model where multiple knowledge sources collaborate by reading from and writing to a shared workspace. We also discussed how modern concepts like AG‑UI, MCP Apps, and agentic frameworks echo these principles in today’s distributed, protocol-driven systems.
-
Blackboard Architecture: A Classic AI Model for Collaborative Problem Solving
Blackboard architecture is a classic AI problem-solving model in which multiple independent knowledge sources cooperate by reading from and writing to a shared global data structure called a blackboard. Instead of a single control program deciding everything, the system evolves its solution incrementally through opportunistic contributions from different specialized modules.
-
LLMs as Equalizers: Translating Ideas Across Ecosystems
This post explores how Large Language Models (LLMs) are changing the way we think about idea sharing and implementation across different programming ecosystems. It argues that LLMs don’t just help with code generation—they’re enabling a new form of translation that makes ideas portable and accessible, regardless of the underlying language or runtime.
-
The Enduring Legacy of QuickCheck: Property-Based Testing in Mainstream Tech Stacks
QuickCheck is a property-based testing library for Haskell that revolutionized how developers think about testing by shifting focus from writing example-based unit tests to specifying general properties that code should satisfy. Its influence spread widely, inspiring similar libraries across mainstream languages like Java, .NET, Node.js, and Python.
-
The Best Way to Prevent Cache Stampedes
In 2026 / .NET 10, the most elegant and idiomatic solution to the cache stampede (dogpile) problem in C# is:
-
Traceability: The Secret Sauce for Engineers to 'Get It'
Traceability really is one of those deceptively simple yet profoundly powerful ideas. 🌱
-
OpenVINO™ Toolkit for AI Inference on Intel Graphics
Intel Xe Graphics (integrated in many Intel CPUs starting with 11th Gen Core processors and newer) can be used for AI inference via Intel’s OpenVINO™ Toolkit.
-
Vulkan: The Low-Level GPU API for AI Inference in 2025
Vulkan is a low-level 3D graphics API, like OpenGL, but with a very different design philosophy. Here’s a software-engineer-level explanation, then why it matters for AI / offline inference.
-
Miraas: A Blast from the Past - Logic Programming Meets Modern C#
Part 4 of a series exploring the technical challenges behind building Miraas, an Islamic inheritance calculator
-
Miraas: Taming Complexity with Domain-Driven Design
Part 3 of a series exploring the technical challenges behind building Miraas, an Islamic inheritance calculator
-
OpenCL: Is It Still Relevant?
OpenCL (Open Computing Language) is an open standard for parallel programming across heterogeneous platforms, including CPUs, GPUs, and other processors. It enables software to run on a variety of hardware types without being tied to a specific vendor (like NVIDIA’s CUDA).
-
C# for Number Crunching?
We can use C# to access our laptop GPUs for number crunching, but with limitations and workarounds, as C# does not natively support GPU computation. Here are your main options:
-
Intel Xe GPUs for General-Purpose Number Crunching?
Intel Xe Graphics GPUs, particularly in their integrated and entry-level discrete forms, are not designed as high-performance general-purpose number-crunching processors, especially compared to NVIDIA CUDA or AMD ROCm ecosystems. However, they can be used for GPGPU (General-Purpose computing on Graphics Processing Units) to some extent through APIs like:
-
Miraas: Choosing Boring Over Shiny
Part 2 of a series exploring the technical challenges behind building Miraas, an Islamic inheritance calculator
-
Miraas: A Software Engineering Perspective on Islamic Inheritance Calculation
Building an Islamic inheritance calculator is like trying to solve a Rubik’s Cube blindfolded. At first glance, it seems like a straightforward problem: take some family relationships, apply some percentages, and output the results. But as any software engineer will tell you, what appears simple often hides a labyrinth of complexity.
-
Empiricism: Agile and Scrum
Empiricism, in the simplest terms, is the idea that knowledge should come from observation, measurement, and experience—not just theory or intuition.
-
Development Loop: IntelliJ's vs Visual Studio
This isn’t just a tooling quirk; it actually shaped how .NET vs Java devs think about their development loop.
-
Effective Chunking and Knowledge Graphs in RAG
Effective Chunking is a common challenge in Retrieval-Augmented Generation (RAG), especially when dealing with structured or semi-structured text like tables, lists, or bullet points. If chunk boundaries split logically connected information, the retriever might miss crucial context.
-
Choosing the Right Stack for GenAI in Microsoft 365
When building Generative AI (GenAI) modules for Microsoft 365 applications, the choice of technology stack is crucial. This decision impacts not just development speed, but also long-term maintainability, hiring strategy, and alignment with Microsoft’s evolving AI ecosystem.
-
Real-World SharePoint Projects and Use Cases
Here are some real-world SharePoint projects that can help you learn SharePoint development:
-
Opportunities for Developers in Microsoft 365 Ecosystem
As a C# developer, there are several opportunities within the Microsoft 365 ecosystem:
-
Microsoft’s TPL Dataflow and Modern Data Engineering
Why Microsoft’s TPL Dataflow Block Has Seen Limited Adoption in Modern Data Engineering?
-
Creating a Generative Model with Infer.NET
Infer.NET is a framework for running Bayesian inference in graphical models. Creating a generative model in Infer.NET typically involves defining a probabilistic model that specifies how data is generated. Here’s a high-level overview of the steps you might follow to create a generative model using Infer.NET:
-
Infer.NET: Bernoulli Distribution and Variable Declaration
Infer.NET is a framework for running Bayesian inference in graphical models. It allows you to define probabilistic models and perform inference to make predictions or understand the underlying data distribution.
-
Data Pipelines in .NET: Beyond I/O Pipes
In .NET, when dealing with data pipelines and task execution, you have several options beyond just using I/O pipes. Here are some key concepts and libraries that can help you implement and manage data pipelines effectively:
-
Motorola 6800 Simulator in C# + Fun Scenarios for Young Engineers
Let’s build a Motorola 6800 (M6800) simulator in C#. We’ll start with a minimal architecture and iterate.
-
System.Numerics.Tensors
System.Numerics.Tensorsis a really nice addition to the .NET ecosystem, and its usefulness goes well beyond NLP. -
AI-Driven Markdown Notes
Microsoft OneNote’s slow pace in innovation—especially compared to newer AI-driven note-taking tools like Notion, Obsidian, or Tana—boils down to a few key factors:
-
The Addictive Power of C# - is { } Pattern
The
is { }pattern in C# is incredibly addictive once you discover it. It’s such a clean way to check for non-null and simultaneously assign to a non-nullable variable. -
Semantic Kernel: The C# AI Toolkit for .NET Developers
Semantic Kernel (SK) is an open-source SDK from Microsoft designed to help developers integrate AI models (like OpenAI or Azure OpenAI) into their applications. The C# version of Semantic Kernel makes it easy for .NET developers to build intelligent apps that combine:
-
The Evolution of Data Science: From Frontier to Infrastructure and the Path Forward
Data science was the buzzword from around 2015 to 2020, but the hype has noticeably cooled. Here’s why:
-
DDD - Entities and Aggregates
In context of Domain Driven Design, Entities and Aggregate confuses lot of people. Let’s unravel the knot:
-
DDD - Context Map
The concept of a Context Map in Domain-Driven Design (DDD) serves as a blueprint for understanding the relationships and interactions between different Bounded Contexts within a system. It explains various relationship patterns such as Shared Kernel, Customer/Supplier, and Anticorruption Layer, and illustrates how these patterns can be applied in a sales order processing example.
-
DDD - Bounded Context
Let’s break down the Bounded Context concept in Domain-Driven Design (DDD) for someone who’s just getting familiar with it.
-
DDD - Subdomains
Subdomains are at the heart of Domain-Driven Design (DDD), and understanding them helps unlock the clarity and modularity that DDD brings to complex systems. Let’s break it down.
-
Becoming a Frontier Engineer: A Roadmap to Innovation
Becoming a frontier engineer—someone building at the edge of what’s possible rather than maintaining the status quo—requires a deliberate shift in mindset, positioning, and skillset. Here’s a strategic roadmap to break free from the industrial mold (e.g., Augmented Teams, feature factories) and step into frontier engineering:
-
More Frontier Engineers
A Frontier Engineer is a professional who works at the cutting edge of technology, science, or exploration. The term “frontier” implies operating in areas that are not yet fully understood, developed, or explored. A Frontier Engineer typically:
-
Elicitation in GenAI Applications
In the context of a model context protocol, elicitation typically refers to the process of gathering, extracting, or soliciting relevant information from a source (often a user, domain expert, or dataset) to inform or populate the context that a model will use during inference or interaction.
-
Celery and Task Queues in different Ecosystems
Celery is a powerful tool for managing background tasks in Python applications. In this post, we’ll explore what Celery is, why it’s useful, and how it compares to other task queues across different programming ecosystems.
-
MCP Ecosystems: A Comparative Analysis
In the world of Generative AI (Gen-AI), the Model Context Protocol (MCP) is becoming a cornerstone for building cross-platform, multi-agent applications. It provides a standardized way to define and invoke tools, manage prompts, and orchestrate complex workflows across different environments. Let’s build on the MCP foundation and look at popular frameworks and toolchains used to build generative AI applications, with a specific lens on which of them support the MCP Client and/or Server.
-
Model Context Protocol
Model Context Protocol (MCP) is a way to give AI models better awareness of their environment and improve how they interact with users or tools in complex systems. Think of it like a shared language or structure that helps the model understand not just a user’s question, but where it’s being asked, why, and what resources it can use to answer it.
-
ECMAScript 2025
Here are the officially standardized new features in ECMAScript 2025 (approved June 25 2025), each with a brief overview and a compact example:
-
Neuromorphic Computing
Neuromorphic Computing is an approach to computing that mimics how the human brain works, in both hardware and software. Instead of relying on the traditional von Neumann architecture (with separate CPU and memory), neuromorphic systems are designed with components that act like biological neurons and synapses, enabling parallel, event-driven processing.
-
Encoders and Decoders in NLP
This article explores the concepts of encoders and decoders in Natural Language Processing (NLP), particularly within the context of Transformer architectures. It explains how encoders like BERT process input sequences to create contextual embeddings, while decoders like GPT generate text by predicting the next token based on previous context. The article also compares these components, discusses their roles in various NLP tasks, and provides a detailed look at the Transformer architecture, including self-attention mechanisms and practical examples.
-
.NET: User Secrets
To switch from storing sensitive configuration data in
appsettings.jsonto User Secrets while still using Visual Studio to publish to Azure, follow these step-by-step instructions: -
Generative AI Concepts
Lets explore fresh perspectives on floats, vectors, and other concepts inspired by Generative AI! These concepts are foundational to modern machine learning and AI, and they can be applied in many creative ways beyond traditional Generative AI. Let’s start by listing some key concepts and techniques that are widely used in AI and machine learning, and then we can dive deeper into any of them:
-
Systematic Poker - II
Systematic Refinement Process for Jira Story Point Prediction
To enable effective ML-driven story point prediction, the refinement process must systematically capture contextual, historical, and team-specific metadata. Below is a structured workflow to standardize inputs while retaining flexibility for real-world engineering practices:
-
Systematic Poker
Lets build a high-level strategy outlining a systematic process for Jira Story Point Prediction. This approach focuses on defining and refining the workflow rather than jumping into the implementation details.
-
Airflow: Sprint Health
Apache Airflow has gained significant popularity in the data engineering and workflow automation space due to a combination of powerful features, flexibility, and strong community support. Below are the key reasons why Apache Airflow stands out as a preferred choice for orchestrating workflows:
-
Smart Sprint Analyzer
That’s a compelling and relatable idea—especially for engineers familiar with Agile practices and tools like Jira. Here’s a refined version of your concept, with a clearer problem definition and TensorFlow relevance, that balances simplicity with educational value:
-
Reliable Timeout Handling
The recommended approach uses RabbitMQ’s Dead Letter Exchange with TTL (Option 1) for reliable timeout handling, where expired messages automatically gets routed. Alternative solutions include delayed messages (if plugin available) or an external scheduler. Always include correlation IDs and ensure idempotency in timeout handling.
-
RabbitMQ Quorum Queues
Quorum queues are a modern queue type in RabbitMQ (introduced in version 3.8.0) designed to provide data safety through replication and exactly-once processing semantics through built-in message deduplication.
-
Recommended Approaches for Idempotent Consumers
Deduplication is critical in messaging systems to ensure exactly-once processing and prevent duplicate side effects. Here are effective approaches based on different infrastructures:
-
DoR: Testing Scenarios
Including testing scenarios in a ticket’s Definition of Ready (DoR) is highly important for ensuring quality, clarity, and efficiency in the development process. Here’s why:
-
NP-Complete Problems
🔍 What are NP Problems?
-
Are we behind?
Electricity began to significantly multiply efficiency and bring monetary benefits very shortly after it became practically usable—within a few decades of key inventions and infrastructure.
-
LLaMa 3.1 8b
Llama 3 8B excels in instruction following and generating structured outputs like JSON. Compared to models like Gemma, it delivers more accurate and reliable responses. Its performance and alignment make it ideal for real-world, prompt-driven applications.
-
Inference Infrastructure
We are already seeing a growing need for dedicated and optimized inference infrastructure for Generative AI, much like the role centralized database engines (e.g. SQL Server, Oracle) played in the enterprise data era. Here’s how and why this trend is emerging:
-
There Are No Stupid Questions in Discovery
Reproducing Dan North’s ‘Ask Me Anything’ blog post using LLM
-
Bayesian Inference
Bayesian inference is a statistical method that allows you to update your beliefs (probabilities) about a hypothesis as you gather new evidence. It’s like writing code that dynamically refines its understanding of the world as data streams in. Here’s how it works, tailored for a software engineer:
-
Distributed Computing Orchestrating Patterns
Patterns for orchestrating messaging and reliability in distributed systems have matured and gained formal recognition. Lets understand and see their implementations using RabbitMQ a famous Message Broker.
-
DDD as a Culture
Domain-Driven Design (DDD) is much more than just a technical methodology. It embodies a philosophy of software modeling rooted in deep collaboration between domain experts and developers. Here’s how your perspective aligns with core DDD thinking:
-
AMD AI MAX+ 395
“The AMD AI Max+ 395 is to AI PCs what the Pentium was to multimedia PCs.”
-
LLM Applications
Here are some popular LLM applications:
-
Cognitive Load Theory
Cognitive Load Theory (CLT) is a psychological framework that explains how human working memory is limited and how instructional design can either hinder or help learning. For software engineers, this means that how we structure code, documentation, and learning materials can either reduce or increase the cognitive burden on ourselves or others.
-
Transitioning to Data Engineering
Transitioning from a Software Engineer to a Data Engineer requires expanding your skill set into areas focused on data processing, storage, and pipeline orchestration. Here’s a structured plan to guide your learning journey:
-
NumPy
Curious about NumPy but not sure where to start? This gentle introduction is tailored for software engineers who want to unlock the power of numerical computing without the math overload.
-
Chain of Thoughts
To implement a chain of thoughts (CoT) using Ollama models like Qwen in C#, you can leverage either the Microsoft AI extensions or Semantic Kernel. Below is a step-by-step guide to help you approach this:
-
Generative AI beyond Chatbots
Generative AI’s potential in enterprise applications extends far beyond chatbots, offering transformative solutions across various domains. Here’s a structured overview of impactful use cases:
-
AI Hype vs Reality
AI is everywhere—but how much of what you hear is real, and how much is just hype? In this post, we cut through the buzzwords to explore what AI can actually do today. Get ready for a grounded look at the promises, pitfalls, and possibilities of artificial intelligence.
-
Fine Tuning SLMs and LLMs: Techniques, Tools, and When to Use Them
We can fine-tune both Small Language Models (SLMs) and Large Language Models (LLMs), and LoRA and PEFT are among the most popular techniques.
-
Prompt Engineering
In generative AI and prompt engineering, Few-shot, System, and Instruction refer to different ways of guiding or controlling a model’s behavior. Here’s what each term means:
-
Learning ML.NET
Here’s a step-by-step plan to learn ML.NET and its NuGet packages effectively:
-
Exploring Infer.NET
How to build custom machine learning models using .NET? Infer.NET opens the door to powerful probabilistic programming with surprising ease. Discover how this hidden gem from Microsoft can transform the way you think about inference and learning.
-
Self Ask
Ever wondered how AI models improve their own responses in real time? Discover the fascinating world of self-rephrasing in frontier models and how it’s quietly transforming human-AI interaction. This post breaks it down simply—no jargon, just insight.
-
Predicting Task Time
This post introduces Linear Regression in a way that’s tailored for software engineers—practical, intuitive, and surprisingly useful. Let’s turn your task estimates from guesswork into data-driven decisions.
-
Predicting Story Points
Predicting story points for Jira stories using regression is a great real-world problem that software engineers can relate to. It’s a common challenge in Agile development, and solving it can improve planning, resource allocation, and sprint predictability. Let’s break this down step by step and align it with a workflow that can be implemented using ML.NET.
-
One-Hot Encoding vs Multi-Hot Encoding
If I am creating one hot embedding vector for say food, let’s say those have keys, pizza, burger, sushi and drink If I am encoding an order that has burger and drink, my encoding vector will be 0 1 0 1?
-
1.58b Tensors and BitNet
Ever wondered how AI models are getting smarter and smaller? BitNet’s use of 1.58b tensors might just be the breakthrough everyone’s been waiting for. Let’s unpack what this means—and why it matters for the future of efficient AI.
-
Tensor Cores vs AVX
Curious how Tensor Cores stack up against AVX when it comes to high-performance computing? This quick dive unpacks the strengths of each, and why your choice might depend on more than just speed.
-
AVX-512 Supported Operations Overview
Ever wondered what makes modern CPUs insanely fast at crunching numbers? AVX-512 might just be the secret sauce. Let’s break down what it is, why it matters, and how it’s shaping the future of performance computing by understanding AVX-512 operations and analyze algorithm compatibility.
-
Understanding Base vs Instruct Models in LLMs
When discussing large language models (LLMs) like Qwen or Llama, it’s crucial to understand the distinction between “base models” and “instruct models.” Here’s a breakdown:
-
Base and Instruct Versions of LLMs
Lets explores the key differences between the Base and Instruct versions of large language models, focusing on Qwen and Llama. It compares their training objectives, capabilities, and suitability for various tasks. The analysis highlights how instruction tuning impacts performance and usability in real-world applications.