<?xml version="1.0" encoding="UTF-8" ?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>AlgoMastery Essays &amp; Modules</title>
    <link>https://algomastery.dev/</link>
    <atom:link href="https://algomastery.dev/rss.xml" rel="self" type="application/rss+xml" />
    <description>A scholarly free curriculum on data structures and algorithms. New essays and concept deep-dives.</description>
    <language>en-us</language>
    <lastBuildDate>Tue, 21 Jul 2026 11:04:25 GMT</lastBuildDate>
    <item>
      <title><![CDATA[DSA study plans that actually work]]></title>
      <link>https://algomastery.dev/blog/learning-paths-that-actually-work</link>
      <guid isPermaLink="true">https://algomastery.dev/blog/learning-paths-that-actually-work</guid>
      <pubDate>Sun, 19 Jul 2026 00:00:00 GMT</pubDate>
      <category>essay</category>
      <description><![CDATA[How long does it take to learn data structures and algorithms? Six to twelve weeks, if the plan matches your deadline. Here are the three study plans behind AlgoMastery's pathways, laid out week by week, and the reasons most self-study plans quietly fail.]]></description>
    </item>
    <item>
      <title><![CDATA[Why your recursive solution works but you cannot explain it]]></title>
      <link>https://algomastery.dev/blog/why-your-recursive-solution-works-but-you-cannot-explain-it</link>
      <guid isPermaLink="true">https://algomastery.dev/blog/why-your-recursive-solution-works-but-you-cannot-explain-it</guid>
      <pubDate>Tue, 21 Jul 2026 00:00:00 GMT</pubDate>
      <category>essay</category>
      <description><![CDATA[Most developers can write a recursive function that passes tests. Far fewer can trace the call stack, name the invariant each frame maintains, or explain why the base case is sufficient. That gap between working code and understood code is where interviews and production incidents live.]]></description>
    </item>
    <item>
      <title><![CDATA[Why arrays beat linked lists in practice]]></title>
      <link>https://algomastery.dev/blog/why-arrays-beat-lists-in-practice</link>
      <guid isPermaLink="true">https://algomastery.dev/blog/why-arrays-beat-lists-in-practice</guid>
      <pubDate>Sun, 19 Jul 2026 00:00:00 GMT</pubDate>
      <category>essay</category>
      <description><![CDATA[Arrays beat linked lists in most real code, and the reason is the memory hierarchy, not Big-O. Here is the cache-locality argument, an honest benchmark sketch, and the short list of cases where a linked list still earns its pointers.]]></description>
    </item>
    <item>
      <title><![CDATA[The Hidden Cost of Premature Abstraction]]></title>
      <link>https://algomastery.dev/blog/premature-abstraction</link>
      <guid isPermaLink="true">https://algomastery.dev/blog/premature-abstraction</guid>
      <pubDate>Thu, 21 May 2026 00:00:00 GMT</pubDate>
      <category>essay</category>
      <description><![CDATA[In algorithm design and in engineering generally, the most expensive bugs are not the ones we make, they are the abstractions we built before we understood the problem. This essay is about why most interview-grade solutions stop at the right level of abstraction, and why production code so often doesn't.]]></description>
    </item>
    <item>
      <title><![CDATA[The texts that taught me algorithms]]></title>
      <link>https://algomastery.dev/blog/the-texts-that-taught-me</link>
      <guid isPermaLink="true">https://algomastery.dev/blog/the-texts-that-taught-me</guid>
      <pubDate>Tue, 14 Apr 2026 00:00:00 GMT</pubDate>
      <category>essay</category>
      <description><![CDATA[A slow reading list: four books that did the heavy lifting when I was learning. What each does best, what each is bad at, and why their strengths don't overlap as much as a glance at their tables of contents suggests.]]></description>
    </item>
    <item>
      <title><![CDATA[Recognise the shape, not the problem]]></title>
      <link>https://algomastery.dev/blog/recognise-the-shape</link>
      <guid isPermaLink="true">https://algomastery.dev/blog/recognise-the-shape</guid>
      <pubDate>Thu, 02 Apr 2026 00:00:00 GMT</pubDate>
      <category>essay</category>
      <description><![CDATA[Interview problems reuse a small catalogue of shapes. The candidate who memorises two hundred problems is running a losing race against the candidate who can classify a new problem in twenty seconds. The difference between them is pattern recognition, a skill that turns out to be learnable.]]></description>
    </item>
    <item>
      <title><![CDATA[Complexity is a contract, not a fact]]></title>
      <link>https://algomastery.dev/blog/complexity-is-a-contract</link>
      <guid isPermaLink="true">https://algomastery.dev/blog/complexity-is-a-contract</guid>
      <pubDate>Fri, 20 Mar 2026 00:00:00 GMT</pubDate>
      <category>essay</category>
      <description><![CDATA["O(n)" is not a measurement. It's a contract: a promise about how running time scales <em>given certain assumptions</em>. When those assumptions fail, the contract is void, and fast algorithms become slow ones. This essay names the three assumptions that most often quietly fail in production.]]></description>
    </item>
    <item>
      <title><![CDATA[Arrays & Sequences]]></title>
      <link>https://algomastery.dev/topics/arrays</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/arrays</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[An array is not a list of things. It is a region of memory, laid out end-to-end, indexed by arithmetic. Once you see arrays as geometry rather than as containers, the patterns that operate on them (two pointers, sliding windows, prefix sums) stop feeling like tricks and start feeling like consequences.]]></description>
    </item>
    <item>
      <title><![CDATA[The Discipline of Pointers]]></title>
      <link>https://algomastery.dev/topics/linked-lists</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/linked-lists</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[A linked list is the refusal to hold memory in one piece. Each node is a signpost: a small payload and an arrow pointing to the next signpost. The price is indirection; the reward is freedom: insertion and deletion at any point cost O(1) if you already have a pointer to it. This is the module where pointers stop being a syntactic curiosity and start being a design tool.]]></description>
    </item>
    <item>
      <title><![CDATA[Advanced String Manipulation]]></title>
      <link>https://algomastery.dev/topics/strings</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/strings</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[Strings are arrays with a finite alphabet: usually ASCII, sometimes Unicode, occasionally just {A, C, G, T}. That constraint is a gift. A small alphabet lets you build lookup tables in constant space, hash prefixes in linear time, and compare substrings in O(1) after O(n) preprocessing. This module is about recognising when the alphabet is small enough to exploit.]]></description>
    </item>
    <item>
      <title><![CDATA[The Algebra of Membership]]></title>
      <link>https://algomastery.dev/topics/hash-maps</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/hash-maps</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[A hash map is a machine that converts the question 'have I seen this key before?' from a linear search into a constant-time lookup. That single capability turns a surprising number of O(n²) brute-force solutions into O(n) linear-time algorithms. Learning the pattern ('keep a hash map of what you've seen, query it on each new element') is the single highest-leverage habit in this curriculum.]]></description>
    </item>
    <item>
      <title><![CDATA[Recursion as Structural Induction]]></title>
      <link>https://algomastery.dev/topics/trees</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/trees</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[Trees are the first data structure where recursion stops being a cute control-flow trick and becomes the only natural language. A binary tree is either empty or a node with two subtrees. Every recursive function over a tree mirrors that definition: the base case handles the empty tree, the recursive case combines the results from the two subtrees. Once you see it, you will never write a tree algorithm iteratively again if you don't have to.]]></description>
    </item>
    <item>
      <title><![CDATA[The Geometry of Optimal Substructure]]></title>
      <link>https://algomastery.dev/topics/dynamic-programming</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/dynamic-programming</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[Dynamic programming is not a trick. It is a discipline: when a problem's optimal answer can be assembled from optimal answers to smaller versions of the same problem, the naive exponential recursion becomes a polynomial-time algorithm, provided you can name the subproblem. This module teaches you to name it.]]></description>
    </item>
    <item>
      <title><![CDATA[The Vocabulary of Relationships]]></title>
      <link>https://algomastery.dev/topics/graphs</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/graphs</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[Almost every problem involving connections (cities by roads, people by friendships, pages by links, tasks by dependencies) is a graph problem in disguise. Learning to recognise the shape is three-quarters of solving it. The other quarter is a small family of algorithms, BFS, DFS, topological sort, and Dijkstra, that, once understood, unlock an enormous surface of real problems.]]></description>
    </item>
    <item>
      <title><![CDATA[The Price of Order]]></title>
      <link>https://algomastery.dev/topics/sorting</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/sorting</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[Sorting is rarely the goal. Sorting is the <em>preparation</em> that makes the real goal cheap: finding duplicates, computing medians, applying two-pointer techniques, answering range queries. This module focuses less on implementing sorts (the standard library will do that better than you) and more on the decision of <em>whether</em> to sort at all, and which algorithmic trick each sorted-input shape unlocks.]]></description>
    </item>
    <item>
      <title><![CDATA[Two Hands on a Number Line]]></title>
      <link>https://algomastery.dev/topics/two-pointers</link>
      <guid isPermaLink="true">https://algomastery.dev/topics/two-pointers</guid>
      <pubDate>Thu, 23 Apr 2026 00:00:00 GMT</pubDate>
      <category>module</category>
      <description><![CDATA[The two-pointer technique and its cousin, the sliding window, are the single most transferable patterns in this curriculum. They appear in array problems, string problems, linked-list problems, and even on graphs with a linearised structure. If you understand why they work, not just how, you will recognise them at first sight, and the O(n²) brute force will feel obviously wrong.]]></description>
    </item>
  </channel>
</rss>