<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Madhumidha on Medium]]></title>
        <description><![CDATA[Stories by Madhumidha on Medium]]></description>
        <link>https://medium.com/@madhumidha22?source=rss-28796b232cc1------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Y322BwabbDBHJQGI</url>
            <title>Stories by Madhumidha on Medium</title>
            <link>https://medium.com/@madhumidha22?source=rss-28796b232cc1------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 16:23:46 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@madhumidha22/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The Hidden Pitfalls of Ablation Studies in Large Language Models]]></title>
            <link>https://levelup.gitconnected.com/the-hidden-pitfalls-of-ablation-studies-in-large-language-models-d7716b30c478?source=rss-28796b232cc1------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7716b30c478</guid>
            <category><![CDATA[ablation]]></category>
            <category><![CDATA[llm-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <dc:creator><![CDATA[Madhumidha]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 15:49:51 GMT</pubDate>
            <atom:updated>2026-10-05T15:49:51.234Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Why removing a component doesn’t always tell us what we think it does.</em></p><p>If you have read even a handful of recent AI papers, you have almost certainly encountered an ablation table. It’s become one of the most recognisable sections in modern machine learning research. The methodology is straightforward: train a complete model, remove one component at a time, evaluate performance and measure how much accuracy drops. The larger the drop, the more important the removed component is assumed to be.</p><p>The simplicity of this approach is precisely why it has become so influential. It offers a clean narrative. Every module earns its place in the architecture by proving that the system performs worse without it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aBn-mERSfZja5N2XpSwkAQ.png" /></figure><p>Yet as Large Language Models evolve into increasingly modular systems, combining retrieval, long-term memory, planning, reasoning, tool execution, reflection and multiple collaborating agents, I find myself questioning whether our interpretation of ablation studies has kept pace with the systems they are designed to evaluate.</p><p>The methodology itself remains valuable. The assumptions we derive from it deserve a closer look.</p><h3>The Experiment Everyone Trusts</h3><p>Consider a typical experiment from a modern LLM-based system.</p><pre>LLM(<br>    planner=True,<br>    retrieval=True,<br>    memory=True,<br>    reflection=True<br>)<br><br># Accuracy = 91.8%</pre><p>The researchers remove the memory module.</p><pre>LLM(<br>    planner=True,<br>    retrieval=True,<br>    memory=False,<br>    reflection=True<br>)<br><br># Accuracy = 84.3%</pre><p>At first glance, nothing appears questionable. The experiment is reproducible, the numbers are measurable, and the conclusion feels intuitive.</p><p>But the experiment only tells us <strong>what happened</strong> after removing memory. It does not necessarily explain <strong>why</strong> it happened. That distinction is subtle, yet increasingly important.</p><h3>Dependency Is Not the Same as Importance</h3><p>Imagine training for a marathon while wearing the same pair of running shoes every single day. Your body gradually adapts to them. On race day, someone replaces those shoes with another pair. You may run slower.</p><p>Did the original shoes make you a better athlete? Probably not.</p><p>Your performance declined because your training had adapted to a particular environment. Modern LLMs exhibit remarkably similar behaviour.</p><p>A system designed and evaluated with retrieval, memory, and planning becomes adapted to operating with those capabilities. When one of them disappears during evaluation, the remaining components are suddenly expected to perform under conditions they were never optimised for.</p><p>The observed performance degradation may therefore reflect <strong>adaptation</strong> as much as <strong>capability</strong>.</p><p>This is where many discussions surrounding ablation quietly oversimplify the problem. A performance drop demonstrates that the current implementation depended on a component under a particular configuration. It does not automatically prove that the component is fundamentally necessary or universally beneficial.</p><p>The distinction between dependency and necessity is rarely discussed, yet it fundamentally changes how we should interpret experimental evidence.</p><h3>Modern AI Systems Are Ecosystems, Not Collections of Independent Modules</h3><p>Traditional ablation often treats individual components as if they can be evaluated in isolation. Modern AI systems rarely behave that way. Consider an autonomous coding assistant.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bthlFruLA3bmmF0TeeA_8A.png" /></figure><p>Now imagine removing the memory module. Memory disappears. But something else happens.</p><p>The planner begins requesting additional retrieval operations. The retrieval engine fetches larger contexts to compensate for the missing historical information. Tool selection changes because previous execution history is no longer available. Token consumption increases. Latency rises. Even the reasoning path taken by the model becomes different.</p><p>Nothing except the memory module was explicitly removed. Everything else quietly adapted.</p><p>I often think of this as a <strong>Cascading Ablation Effect (CAE), </strong>the indirect behavioural changes that propagate through interconnected components after removing a single subsystem.</p><p>The experiment still measures performance. However, the resulting performance is now influenced by an entirely different execution strategy. In complex architectures, removing one module rarely removes only one capability. It changes the behaviour of the entire ecosystem.</p><h3>The Binary Nature of Ablation</h3><p>Another limitation lies in how we perform the experiment itself. Most ablation studies reduce architectural decisions to binary choices.</p><pre>memory = True</pre><p>or</p><pre>memory = False</pre><p>Reality is rarely binary. A conversational chatbot answering simple factual questions may gain almost nothing from persistent memory. An autonomous research agent operating continuously for several hours may depend on it heavily. The usefulness of a component is often contextual rather than absolute.</p><p>Instead of completely disabling a subsystem, imagine gradually reducing its contribution.</p><pre>memory_capacity = 1.00<br>memory_capacity = 0.75<br>memory_capacity = 0.50<br>memory_capacity = 0.25<br>memory_capacity = 0.00</pre><p>Rather than producing a single before-and-after comparison, the experiment now reveals how system performance changes as available memory decreases.</p><p>Some capabilities may degrade gracefully. Others may collapse almost immediately. That response curve contains considerably more information than a binary experiment ever could.</p><h3>Beyond the Ablation Table: Measuring Evidence, Not Just Performance</h3><p>An ablation table can tell us that removing a component changed performance, but it tells us much less about how reliable or meaningful that change actually is. A stronger evaluation looks beyond the final percentage: Was the model retrained after the component was removed? Does the result hold across different datasets, models, and random seeds? And does the performance gain justify the additional latency, inference cost, memory usage, or architectural complexity?</p><p>This is where <strong>Component Evidence Strength (CES)</strong> becomes a useful mental model. A component supported by a single benchmark provides some evidence; one that consistently improves results across models, datasets, repeated runs, and practical constraints provides considerably stronger evidence. The goal is therefore not simply to ask whether a module improves performance, but to understand <strong>how convincing that improvement is and whether it remains valuable outside the exact experiment in which it was observed</strong>. Evaluation should also measure whether the improvement is worth the complexity it introduces.</p><h3>Final Thoughts</h3><p>Ablation studies are not broken. They remain a valuable tool for understanding complex AI systems. The challenge is interpreting their results with the right level of confidence.</p><p>As LLMs become interconnected systems of memory, retrieval, planning, reasoning, and tools, removing one component can change the behaviour of everything around it. A performance drop may show dependency, but not necessarily necessity.</p><p>And performance alone is not enough. A component that improves accuracy by 1% while doubling response time or inference cost may be a research gain, but a poor engineering trade-off.</p><p>Perhaps the better question is no longer <em>what happens when a module disappears?</em></p><p>It is:</p><p><strong>What does the rest of the system become once it is gone?</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7716b30c478" width="1" height="1" alt=""><hr><p><a href="https://levelup.gitconnected.com/the-hidden-pitfalls-of-ablation-studies-in-large-language-models-d7716b30c478">The Hidden Pitfalls of Ablation Studies in Large Language Models</a> was originally published in <a href="https://levelup.gitconnected.com/">Level Up Coding</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Has Been Learning to Talk. What If the Next Step Is Learning to Decide?]]></title>
            <link>https://medium.com/@madhumidha22/ai-has-been-learning-to-talk-what-if-the-next-step-is-learning-to-decide-3a3da23a0c37?source=rss-28796b232cc1------2</link>
            <guid isPermaLink="false">https://medium.com/p/3a3da23a0c37</guid>
            <category><![CDATA[decisions]]></category>
            <category><![CDATA[type-safe]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[jevs]]></category>
            <category><![CDATA[model]]></category>
            <dc:creator><![CDATA[Madhumidha]]></dc:creator>
            <pubDate>Fri, 25 Sep 2026 21:17:41 GMT</pubDate>
            <atom:updated>2026-09-25T21:17:41.782Z</atom:updated>
            <content:encoded><![CDATA[<p>For the past few years, the AI story has mostly been about language. We built models that write, summarise, explain, code, and reason, and chat became the default interface for almost everything people did with AI.</p><p>But there’s a gap hiding underneath that progress: software doesn’t always need an answer written in English. Often, it just needs a <strong>Decision</strong>.</p><p>Should this ticket be escalated? Which tool should an agent call? Is this document relevant? Should a human review this request? Should a workflow continue or stop? For questions like these, generating a paragraph and then asking the software to interpret it feels like an unnecessary detour. That’s the gap <strong>TypeSafe AI</strong> is trying to address with <strong>Jev</strong>, its newly introduced model, and it’s worth understanding why.</p><h3>A different kind of model</h3><p>TypeSafe describes Jev as its first “System One” model, a category built around fast, structured decision-making rather than text generation. The underlying idea is simple: <strong>state → question → decision → action</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jdLowghbCRh9FKfwgwUBUw.png" /></figure><p>You give Jev some context and a focused question. Instead of a sentence, it returns a structured result: a choice, a score, a yes/no with a confidence value attached. Take a support ticket. Instead of asking a language model to “read this ticket and tell me whether it should be escalated,” you frame it as a direct question:</p><pre>Question:<br>Should this ticket be escalated?<br>Result:<br>YES - 0.94</pre><p>Nothing here needs to be parsed out of generated text. The software can simply use it. That distinction sounds small. I don’t think it is.</p><h3>We’ve been using LLMs for everything</h3><p>One side effect of the LLM boom is that the language model has quietly become the default answer to almost every AI problem. Need classification? Use an LLM. Need routing? Use an LLM. Need to pick a tool, or decide whether an agent should retry? Same answer.</p><p>And it works, surprisingly well, in fact. But it also means we’re often using a model built for generating language to do work where the actual output is just a small decision. A typical agent pipeline looks something like this:</p><pre>User Request<br>     ↓<br>    LLM<br>     ↓<br>&quot;Based on the context, I think...&quot;<br>     ↓<br>Parse the response<br>     ↓<br>Validate the output<br>     ↓<br>Choose a tool<br>     ↓<br>Execute</pre><p>Jev points to a different shape:</p><pre>User Request<br>     ↓<br>    LLM<br>     ↓<br>Understand / reason<br>     ↓<br>    Jev<br>     ↓<br>Structured decision<br>     ↓<br>Execute</pre><p>The LLM still handles understanding and generation. A specialised model handles the decision. That’s a more interesting proposition than “here’s another model to try”; it’s a division of labour.</p><h3>The bigger shift: AI as a software primitive</h3><p>This is the part of Jev I find most compelling. TypeSafe frames the model almost like an intelligence function call: <strong>unstructured state </strong>goes in, typed probabilistic decisions come out.</p><p>Consider what changes when intelligence becomes something software can call the way it calls an API. Instead of asking, “Can you determine whether this customer is likely to churn, and explain your reasoning?”, your application asks a narrower question:</p><pre>Score:<br>How likely is this customer to churn?<br>Output:<br>0.87</pre><p>Then ordinary code takes it from there:</p><pre>if score &gt; threshold:<br>    trigger_retention_workflow()<br>else:<br>    continue_normal_flow()</pre><p>The key detail: the model doesn’t own the workflow. The software does. The model supplies judgment exactly at the point where writing a hard-coded rule becomes impractical. It’s a subtle change, but it’s an architectural one.</p><h3>Why this matters for AI agents</h3><p>Agents are usually described with a simple formula:</p><blockquote>LLM + Tools + Memory + Context = Agent.</blockquote><p>But there’s a layer that formula tends to skip over: <strong>decision-making</strong>. An agent with a dozen possible actions still has to answer a string of smaller questions along the way: Which tool should it call? Should it call one at all? Should it retry, ask the user, trust the result, or hand the task to a human?</p><p>Those are all decisions, and they’re exactly what TypeSafe is targeting. Its published workflow examples span security incidents, invoice processing, customer service, and evaluating agent traces, all bounded, judgment-heavy tasks rather than open-ended generation.</p><p>That raises an interesting possibility: future agents might look less like one model doing everything, and more like a set of specialised components working together.</p><pre>                AI Agent<br>                    │<br>        ┌───────────┼───────────┐<br>        ↓           ↓           ↓<br>    Generate     Retrieve     Decide<br>        │           │           │<br>       LLM         RAG          Jev<br>        │           │           │<br>        └───────────┼───────────┘<br>                    ↓<br>                  Tools</pre><p>One model generates. Another retrieves. A third decides. No single model has to carry the whole job.</p><h3>The interesting part isn’t “Jev is faster”</h3><p>TypeSafe reports large speed and cost differences across the workflows it evaluated, claims of up to <strong>193.6× faster</strong> and <strong>444.6× cheaper</strong>. Those numbers come from TypeSafe’s own internal benchmarks, so it’s fair to treat them as vendor-reported rather than independently verified.</p><p>But the more interesting question isn’t whether Jev beats an LLM on speed. It’s this: why are we asking a language model to make every decision in the first place? That’s the question worth sitting with.</p><h3>There’s a real trade-off here</h3><p>Jev isn’t pitched as a replacement for everything. If the task is writing an email, generating code, or explaining an open-ended concept, a generative model is still the right tool. A decision model works precisely because the problem is bounded, you define the question, you define the possible outputs, and the model supplies the judgment. What happens with that judgment is still up to the application.</p><p>TypeSafe’s own documentation is upfront about this: generative models remain the better choice for writing, arithmetic, long-horizon planning, and anything that genuinely requires generation or exact computation.</p><p>So this isn’t really a story about Jev replacing LLMs. It’s a story about not asking one model to be responsible for every kind of intelligence your application needs.</p><h3>What comes next</h3><p>For years, we’ve been fascinated by models that can talk like us. The next interesting step might be models that quietly sit inside software and make thousands of small judgments, a support system deciding what needs escalation, a coding agent deciding whether an action is safe, a search system deciding which results deserve attention, a workflow deciding when to keep going and when to ask for help.</p><p>None of that requires another paragraph. It requires a decision.</p><p>Maybe that’s where AI is heading next, not toward one model that does everything, but toward systems built from several models, each responsible for a specific kind of intelligence: one that generates, one that retrieves, one that evaluates, one that decides!!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3a3da23a0c37" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Agent Observability: The Missing DevOps Layer for AI Applications]]></title>
            <link>https://medium.com/@madhumidha22/agent-observability-the-missing-devops-layer-for-ai-applications-d9eecd70ea23?source=rss-28796b232cc1------2</link>
            <guid isPermaLink="false">https://medium.com/p/d9eecd70ea23</guid>
            <category><![CDATA[observability]]></category>
            <category><![CDATA[agent-observability]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Madhumidha]]></dc:creator>
            <pubDate>Sun, 05 Jul 2026 17:16:40 GMT</pubDate>
            <atom:updated>2026-07-06T08:15:30.372Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(The “missing” layer discussed here is about operational maturity, not tooling availability.)</em></p><p>Over the past year, the conversation around AI has shifted dramatically. We are no longer just building applications powered by large language models; we are building agents.</p><p>These agents can reason, plan, use tools, retrieve information, maintain memory, and even collaborate with other agents to accomplish complex tasks. Every new framework promises more autonomy, better reasoning capabilities, and increasingly sophisticated workflows.</p><p>The progress has been remarkable.</p><p>But after spending time building and experimenting with agentic systems, I’ve started to realise that the biggest challenge isn’t creating intelligent agents.</p><p>It’s understanding what they’re actually doing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6h2RxrdrzDR2BsGlZELaJQ.png" /></figure><h3>The Problem Isn’t Intelligence</h3><p>In traditional software engineering, we’ve spent decades developing systems that are observable.</p><p>When an application fails, we can inspect logs, monitor metrics, analyse traces, and usually identify the root cause. Modern software systems are complex, but we’ve built an entire ecosystem of tools to help us understand their behaviour.</p><p>AI agents introduce a fundamentally different challenge. Consider a relatively simple task:</p><blockquote><em>“Research the latest developments in AI infrastructure and prepare a summary report.”</em></blockquote><p>To accomplish this task, an agent might:</p><ul><li>Break the problem into smaller objectives</li><li>Retrieve information from memory</li><li>Search external sources</li><li>Select and invoke tools</li><li>Evaluate intermediate results</li><li>Revise its original plan</li><li>Collaborate with another specialised agent</li><li>Generate a final response</li></ul><p>Now imagine the report contains incorrect information. Where exactly did the failure occur?</p><p>Did the agent formulate a poor plan? Did it retrieve outdated information? Did it choose the wrong tool? Was there a flawed assumption during the reasoning process? Or did a collaborating agent introduce the error?</p><p>These aren’t questions that traditional observability tools were designed to answer.</p><h3>Traditional Observability Stops at “What”</h3><p>Modern observability is built around three core pillars:</p><ul><li>Logs</li><li>Metrics</li><li>Traces</li></ul><p>These work exceptionally well for traditional software systems because most systems are deterministic. Given the same input, we generally expect the same output.</p><p>Agentic systems don’t behave this way. A simple log entry might tell us:</p><pre>Tool: WebSearch<br>Status: Success<br>Latency: 421ms</pre><p>But that information doesn’t answer the questions engineers actually care about:</p><ul><li>Why did the agent choose this tool?</li><li>What information influenced that decision?</li><li>Which memory was retrieved?</li><li>What alternative paths were considered?</li></ul><p>Traditional observability tells us <strong>what happened</strong>. Agentic systems require us to understand <strong>why it happened</strong>. And that distinction changes everything.</p><h3>What Does Agent Observability Actually Mean?</h3><p>As AI agents become increasingly autonomous, I believe we’ll need an entirely new observability layer designed specifically for agentic systems. Traditional monitoring focuses on system behaviour, but agent observability must provide visibility into how agents think, decide, and act.</p><h3>Understanding Agent Decisions</h3><p>One of the biggest challenges in debugging AI agents is understanding their decision-making process. Unlike traditional applications, agents don’t simply execute predefined instructions; they plan, reason, and adapt based on context. Observability systems should help answer questions such as:</p><ul><li>How did the agent execute the task?</li><li>Why did it choose a particular strategy?</li><li>What assumptions influenced its reasoning?</li></ul><p>Without visibility into execution traces and reasoning paths, diagnosing failures becomes significantly more difficult.</p><h3>Observing Memory and Tool Usage</h3><p>Modern agents rely heavily on memory systems and external tools. A single task may involve retrieving historical context, querying databases, browsing the web, or interacting with multiple APIs.</p><p>To operate agents reliably, we need to understand:</p><ul><li>Which memories influenced the final decision?</li><li>Which tools were invoked and why?</li><li>How did external interactions affect the outcome?</li></ul><p>As agents become more capable, memory retrieval and tool execution will become just as important to monitor as database queries and API calls are in traditional software systems.</p><h3>Monitoring Multi-Agent Systems and Operational Costs</h3><p>The challenge becomes even more complex in multi-agent architectures, where multiple agents collaborate to solve a task. Understanding how agents communicate, delegate work, and propagate errors will be essential for debugging and reliability.</p><p>Additionally, agentic systems introduce a new operational concern: <strong>Cost</strong>. A single request can trigger multiple model calls, retrieval operations, reflection loops, and tool executions. Observability, therefore, isn’t just about understanding technical behaviour; it’s also about understanding the economic behaviour of autonomous systems.</p><h3>Are We Witnessing the Next Evolution of DevOps?</h3><p>This situation feels surprisingly familiar.</p><p>As software systems evolved from monoliths to distributed architectures, the industry developed entirely new disciplines around monitoring, reliability, and observability.</p><p>Without those advancements, modern cloud-native systems would be impossible to operate. I believe Agentic AI is approaching a similar inflection point.</p><p>As agents become increasingly autonomous, we’ll likely see the emergence of entirely new categories of tooling:</p><ul><li>Agent tracing platforms</li><li>Agent debugging systems</li><li>Agent replay mechanisms</li><li>Memory inspection tools</li><li>Agent evaluation frameworks</li><li>Reliability and governance platforms</li></ul><p>In many ways, we may be witnessing the early stages of a new engineering discipline: <strong>Agent Operations</strong>.</p><h3>Final Thoughts</h3><p>Today, much of the AI industry’s attention is focused on building smarter agents. But intelligence alone has never been enough to make software successful.</p><p>The systems that succeed in production are the ones that engineers can understand, monitor, debug, and trust.</p><p>Perhaps the biggest challenge in Agentic AI isn’t teaching agents how to think. It’s learning how to observe them once they do.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d9eecd70ea23" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Beyond Syntax: Understanding the Ideas Behind Clojure]]></title>
            <link>https://medium.com/@madhumidha22/beyond-syntax-understanding-the-ideas-behind-clojure-567381b31e3e?source=rss-28796b232cc1------2</link>
            <guid isPermaLink="false">https://medium.com/p/567381b31e3e</guid>
            <category><![CDATA[clojurescript]]></category>
            <category><![CDATA[programing-language]]></category>
            <category><![CDATA[clojure]]></category>
            <category><![CDATA[concurrency]]></category>
            <category><![CDATA[immutability]]></category>
            <dc:creator><![CDATA[Madhumidha]]></dc:creator>
            <pubDate>Wed, 03 Jun 2026 15:34:43 GMT</pubDate>
            <atom:updated>2026-06-03T15:34:43.045Z</atom:updated>
            <content:encoded><![CDATA[<p>When developers discuss programming languages, the conversation often revolves around popularity, ecosystem size, job opportunities, or performance benchmarks. Languages such as JavaScript, Python, Java, Go, and Rust dominate these discussions because they power a significant portion of modern software.</p><p><strong>Clojure</strong> rarely appears in the same category.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*o1saJa_s1vXSvxNZgKLoWw.png" /><figcaption>Clojure</figcaption></figure><p>Its community is relatively small, job opportunities are limited compared to mainstream languages, and many developers have never written a single line of Clojure code. Yet despite its niche status, Clojure continues to attract attention from software engineers, language enthusiasts, and system architects.</p><p>What makes Clojure interesting is not its syntax, its <strong>Lisp</strong> heritage, or even its macro system.</p><p>While exploring the language, I realised that many ideas often considered modern, immutable state, functional composition, data-oriented design, and safer concurrency, have been central to Clojure’s philosophy for years. Even more interesting is how these ideas continue to influence technologies that many developers use every day.</p><p>This article is not a tutorial on Clojure syntax. Instead, it is an exploration of the ideas that make the language worth studying, even if you never use it professionally.</p><h3>Looking Beyond the Parentheses</h3><p>For many developers, their first encounter with Clojure looks something like this:</p><pre>(defn square [x]<br>  (* x x))</pre><p>The reaction is usually predictable.</p><blockquote>Why are there so many parentheses?</blockquote><p>The unusual syntax often becomes the primary focus of discussions about Clojure. However, after spending some time with the language, it becomes clear that the syntax is one of the least interesting aspects of it.</p><p>The parentheses exist because Clojure inherits the <strong>Lisp</strong> tradition of representing code as lists. Once the syntax becomes familiar, the focus shifts from how code looks to how software is structured.</p><p>The real value of Clojure lies not in its appearance but in the principles that shape the language.</p><h3>Data Over Objects</h3><p>One of the first concepts that stood out to me was Clojure’s emphasis on data. Many programming languages encourage developers to model systems through classes and objects.</p><p>A simple user model in Java might look like this:</p><pre>public class User {<br>    private String name;<br>    private int age;<br>    public User(String name, int age) {<br>        this.name = name;<br>        this.age = age;<br>    }<br>}</pre><p>This approach is familiar and widely used. Clojure takes a different route.</p><pre>(def user<br>  {:name &quot;Madhu&quot;<br>   :age 20})</pre><p>Instead of defining a class, creating constructors, and managing object hierarchies, data is represented directly using maps, vectors, sets, and lists.</p><p>Need the user’s name?</p><pre>(:name user)</pre><pre>;; &quot;Madhu&quot;</pre><p>Need to update the age?</p><pre>(assoc user :age 22)</pre><p>This approach may seem simplistic at first, but it aligns surprisingly well with how modern software systems actually operate. Most systems eventually convert complex objects into simple data structures.</p><p>Clojure begins with data rather than treating it as a secondary concern.</p><h3>Immutability as a Default</h3><p>One of the most influential ideas in Clojure is <strong>immutability</strong>. In many languages, changing state is the default behaviour.</p><pre>user.points += 100;</pre><p>The original object changes. Every part of the system referencing that object now sees the updated value.</p><p>While convenient, mutable state introduces complexity as applications grow. Understanding a program often requires tracking when data changes, who changed it, and what the previous state looked like.</p><p>Clojure approaches the problem differently.</p><pre>(update user :points + 100)</pre><p>Rather than modifying the existing value, a new version is created. The original data remains unchanged.</p><p>This design offers several advantages:</p><ul><li>Easier debugging</li><li>More predictable behaviour</li><li>Safer concurrent execution</li><li>Better reasoning about program state</li></ul><p>At first, creating new values instead of updating existing ones feels unusual. Over time, however, it becomes easier to understand why so many modern frameworks and libraries encourage immutable patterns.</p><p>React state updates, Redux stores, event sourcing systems, and many functional programming techniques all build upon similar ideas.</p><h3>Concurrency as a State Problem</h3><p>Modern applications increasingly rely on <strong>concurrency</strong>.</p><p>Web servers handle thousands of requests. Distributed systems execute operations across multiple machines. Unfortunately, concurrency often introduces difficult bugs. Race conditions, deadlocks, and synchronisation issues frequently arise when multiple threads interact with shared mutable state.</p><p>Clojure addresses this problem by minimising mutable state in the first place. For situations where the state must change, the language provides specialised tools.</p><p>One example is the atom:</p><pre>(def counter (atom 0))</pre><pre>(swap! counter inc)</pre><p>Multiple threads can safely update the counter without explicit locking logic. The developer focuses on the state transition rather than synchronisation details.</p><p>Clojure also provides refs, agents, futures, and Software Transactional Memory (STM), each designed for different concurrency requirements.</p><p>What makes this approach interesting is that concurrency is treated as a state-management problem rather than merely a thread-management problem.</p><h3>The REPL Experience</h3><p>Perhaps the most underrated aspect of Clojure is the <strong>REPL</strong>. REPL stands for <strong>Read-Eval-Print Loop</strong>. Most development workflows follow a familiar pattern:</p><blockquote>Write code → Compile → Run → Observe output → Repeat</blockquote><p>The REPL enables a more interactive style of development. For example:</p><pre>(+ 10 20)</pre><pre>;; =&gt; 30</pre><p>While this example is simple, the concept extends far beyond basic calculations.</p><p>Developers can:</p><ul><li>Evaluate functions instantly</li><li>Inspect application state</li><li>Test transformations interactively</li><li>Experiment without restarting applications</li></ul><p>The feedback loop becomes dramatically shorter.</p><p>Many experienced Clojure developers describe the REPL as one of the language’s most valuable features, and it is easy to understand why. Rapid experimentation often leads to faster learning and more productive development.</p><h3>Code as Data</h3><p>One of Clojure’s most distinctive characteristics is that code itself is represented as data.</p><p>A function call:</p><pre>(+ 1 2)</pre><p>is also a list.</p><pre>&#39;(+ 1 2)</pre><p>This concept, often referred to as <strong>homoiconicity</strong>, enables powerful metaprogramming capabilities. Because programs are represented using ordinary data structures, code can be manipulated using the same techniques used to manipulate regular data. This design forms the foundation of Clojure’s macro system.</p><p>Although macros can become complex, the underlying idea is fascinating: programs can transform programs. Few mainstream languages offer this level of flexibility in such a natural way.</p><h3>Why Clojure Still Matters</h3><p>If Clojure introduces so many interesting ideas, why isn’t it more popular?</p><p>A combination of factors contributed to its niche status: unfamiliar Lisp syntax, the learning curve of functional programming, a smaller ecosystem, and the dominance of Java on the JVM.</p><p>Yet popularity and influence are not the same thing.</p><p>Many ideas that Clojure championed years ago are now common across modern software development:</p><ul><li>Immutable state management</li><li>Functional composition</li><li>Data-oriented design</li><li>Event-driven architectures</li><li>Safer concurrency models</li></ul><p>That’s why Clojure remains worth exploring. Even if it never becomes your primary language, it offers a different perspective on state, data, and software complexity, ideas that remain valuable regardless of the technologies you use.</p><h3>Final Thoughts</h3><p>Learning Clojure did not convince me to abandon the languages I already use. What it did do was challenge several assumptions I had about software design.</p><p>It demonstrated that data can often be more important than objects. It showed how immutability can simplify reasoning about programs. It highlighted the value of functional composition and interactive development.</p><p>Most importantly, it reinforced the idea that programming languages are more than syntax. They are collections of ideas, and sometimes the most valuable ideas come from places far outside the mainstream.</p><p>Clojure may never rival the popularity of JavaScript or Python, but its influence can be seen across software development. For that reason alone, it remains one of the most interesting languages I have explored.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=567381b31e3e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Homebrew Is Not Just a Package Manager. It’s a Build Orchestrator.]]></title>
            <link>https://medium.com/@madhumidha22/homebrew-is-not-just-a-package-manager-its-a-build-orchestrator-8482c5cf8d45?source=rss-28796b232cc1------2</link>
            <guid isPermaLink="false">https://medium.com/p/8482c5cf8d45</guid>
            <category><![CDATA[macos]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[homebrew]]></category>
            <category><![CDATA[automation]]></category>
            <dc:creator><![CDATA[Madhumidha]]></dc:creator>
            <pubDate>Wed, 31 Dec 2025 14:51:10 GMT</pubDate>
            <atom:updated>2025-12-31T14:55:01.788Z</atom:updated>
            <content:encoded><![CDATA[<p><em>(And once you see it this way, everything clicks.)</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FW6e8JNj5EwOU4m_6omI8A.jpeg" /><figcaption>Homebrew</figcaption></figure><h3>The Lie We All Tell Ourselves</h3><p>We casually say:</p><blockquote><em>“Homebrew is a package manager for macOS.”</em></blockquote><p>Technically? Sure.<br>Accurately? Not really.</p><p>Calling Homebrew <em>just</em> a package manager hides what it actually does — and why it feels so reliable.</p><p>Homebrew doesn’t just install software. It <strong>coordinates builds</strong>, <strong>manages binaries</strong>, and <strong>controls where your system looks for tools</strong>.</p><p>That’s not simple package management. That’s orchestration.</p><h3>What a “Package Manager” Usually Means</h3><p>When you hear <em>package manager</em>, you probably think:</p><ul><li>Download a package</li><li>Unzip it</li><li>Put it somewhere</li><li>Done</li></ul><p>That works fine… until:</p><ul><li>versions clash</li><li>paths break</li><li>builds fail</li><li>uninstalling becomes archaeology</li></ul><p>Homebrew avoids this chaos by doing something smarter.</p><h3>What Homebrew Actually Orchestrates</h3><p>Homebrew sits in the middle of <strong>four moving parts</strong> and makes sure they never fight.</p><h3>1. Source vs Prebuilt Binaries</h3><p>Homebrew decides:</p><ul><li><em>Should I download a bottle (precompiled binary)?</em></li><li><em>Or should I build this from source on this machine?</em></li></ul><p>You don’t decide. Your OS, CPU, and environment decide — Homebrew just coordinates it.</p><h3>2. Dependencies (Without Global Chaos)</h3><p>When a tool needs other tools:</p><ul><li>Homebrew installs them <strong>once</strong></li><li>Versions are isolated</li><li>Nothing leaks into system directories</li></ul><p>No /usr/bin disasters. No broken macOS updates.</p><h3>3. Versioned Installs (The Cellar Model)</h3><p>Homebrew doesn’t overwrite software. It stores versions like this:</p><pre>Cellar/<br>  node/<br>    18.19.0/<br>    20.11.0/</pre><p>Multiple versions can exist. Only one is <em>active</em>.</p><p>That’s orchestration — not copying files.</p><h3>4. Symlinks as Contracts</h3><p>Homebrew doesn’t expose raw binaries. It creates <strong>symbolic links</strong>:</p><pre>/opt/homebrew/bin/node → Cellar/node/20.11.0/bin/node</pre><p>This means:</p><ul><li>Upgrades are instant</li><li>Rollbacks are safe</li><li>Your PATH stays clean</li></ul><p>The symlink is the contract. The Cellar is the truth.</p><h3>Why brew install Feels Boring (In a Good Way)</h3><p>Good orchestration is invisible.</p><p>When you run:</p><pre>brew install something</pre><p>You don’t see:</p><ul><li>build steps</li><li>dependency graphs</li><li>filesystem decisions</li><li>platform-specific logic</li></ul><p>And that’s the point.</p><p>Homebrew absorbs complexity so your terminal stays calm.</p><h3>The Mental Model That Finally Clicks for Me</h3><p>Here’s the reframing that changed everything:</p><blockquote><strong><em>Cargo orchestrates builds for a project.<br> Homebrew orchestrates builds for your operating system.</em></strong></blockquote><p>Same philosophy. Different scope.</p><p>Once you see that, Homebrew stops being “magic” and starts being <strong>predictable</strong> — and predictability is the real superpower.</p><h3>Why This Matters (Especially for Developers)</h3><p>Understanding this changes how you:</p><ul><li>debug broken installs</li><li>clean your system</li><li>migrate machines</li><li>trust upgrades</li><li>explain tools to others</li></ul><p>You stop <em>hoping</em> Homebrew works and start <em>knowing</em> why it does.</p><h3>Final Thought</h3><p>Homebrew doesn’t manage packages. It manages <strong>relationships</strong>:</p><ul><li>between versions</li><li>between binaries</li><li>between your system and your tools</li></ul><p>That’s orchestration. And once you see it that way, you’ll never type brew install the same again!! 🍻</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8482c5cf8d45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Panic-Pushed My API Key to GitHub at 3 AM & Here’s How I Fixed It]]></title>
            <link>https://medium.com/@madhumidha22/i-panic-pushed-my-api-key-to-github-at-3-am-heres-how-i-fixed-it-2df216603f4e?source=rss-28796b232cc1------2</link>
            <guid isPermaLink="false">https://medium.com/p/2df216603f4e</guid>
            <category><![CDATA[developer-mistakes]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[api-security]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[env]]></category>
            <dc:creator><![CDATA[Madhumidha]]></dc:creator>
            <pubDate>Sun, 22 Jun 2025 17:05:57 GMT</pubDate>
            <atom:updated>2025-06-22T17:11:09.612Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A terminal window with a message: “Accidentally exposed a SECRET? Here is the FIX!”." src="https://cdn-images-1.medium.com/max/700/1*2BEqHYJpTAbJHcSyzOpKsg.png" /></figure><p>It was 3:07 AM. I had just deployed my astronomy project that used the NASA APOD API. Everything worked perfectly. I was proud. But then… I got an email from GitHub.</p><blockquote><em>“</em><strong><em>GitGuardian has detected the following Generic High Entropy Secret exposed within your GitHub account.</em></strong><em>”</em></blockquote><p>I blinked. Then I realised that I had accidentally pushed my <strong>API key into version control</strong>. If you’re a developer, chances are you’ve either done this, almost done this, or will do it someday. So here’s exactly what happened, how I <strong>cleaned my Git history</strong>, and how I now <strong>prevent it from ever happening again</strong>.</p><h3><em>The Mistake: A Hidden .jsx Leak</em></h3><p>In my case, the leak didn’t come from a .env file. It was sneakier; my API key was <strong>hardcoded</strong> inside a component file APOD.jsx.</p><pre>const API_KEY= &#39;MY_API_KEY;</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MZAYC-zEtFkoGHRlF3t-7A.png" /></figure><p>I had made a temporary API call during testing and forgot to remove it before pushing the code. GitHub indexed it &amp; GitGuardian flagged it. I removed the API Key in that file and pushed to the repo (but too late, it’s still in the commit history. But eventually, I fixed it.</p><h3><strong><em>The Fix: Cleaning Git History Properly</em></strong></h3><p>You need to <strong>rewrite your Git history</strong> to erase all traces of it. By this method, the file will be removed entirely from both GitHub and commits. In simple words, the codes below will <strong>rewrite your Git history</strong>, removing all traces of the file from previous commits.</p><p>Here’s how I did it using an git filter-branch</p><pre>git filter-branch --index-filter &quot;git rm -rf --cached --ignore-unmatch [your/file/path]&quot; HEAD</pre><p>Replace [your/file/path] with the path to your actual file (e.g., src/pages/Secrets.jsx)</p><p>Then, I force-pushed the changes to GitHub,</p><pre>git push --force</pre><p>And that’s it! Now, if you still need that file (but without secrets), you can add it back safely with a proper configuration system.</p><h3><em>Prevention: What You MUST Do Next</em></h3><p>After going through that mess, I learned <strong>never to trust myself with secrets</strong> in plain code.</p><ol><li><strong>Use Environment Variables (</strong>.env<strong> </strong>File<strong>)</strong></li></ol><p>Instead of hardcoding API keys, store them in <em>.</em>env<em> </em>file and use them. Make sure to install the dotenv package (npm install dotenv) .</p><pre>API_KEY = your_key</pre><pre>require(&#39;dotenv&#39;).config();<br>const API_KEY = process.env.API_KEY;</pre><p>Then add this to your .gitignore This ensures your key stays local and never enters version control.</p><p><strong>2. Use a Config File</strong></p><p>If you want to centralise settings, use a config.json file and use it.</p><pre>{<br>  &quot;API_KEY&quot; : &quot;your_key&quot;<br>}</pre><pre>const { API_KEY } = require(&quot;./config.json&quot;);</pre><p><strong>3. Add Git Ignore Early</strong></p><p>Make sure .gitignore is set before your first commit.</p><pre>.env<br>config.json</pre><h3>Final Thoughts</h3><p>Pushing an API key to GitHub might feel like a nightmare — and it is.<br>But it’s also <strong>a rite of passage</strong> for many developers.</p><p>The real mistake isn’t pushing the key.<br>The real mistake is not learning how to fix it and prevent it next time.</p><p>Leave a clap if it helped, comment if you’ve faced something similar, save it and share it. Maybe one day, at 3 AM, you will thank me.</p><p><strong>Wanna connect?</strong><br><a href="https://www.linkedin.com/in/madhumidha-s-0579bb214/">LinkedIn</a> | <a href="https://github.com/Madhumidha-S">GitHub</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2df216603f4e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>