<?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 Rafal Kokoszka on Medium]]></title>
        <description><![CDATA[Stories by Rafal Kokoszka on Medium]]></description>
        <link>https://medium.com/@rafikoko?source=rss-2e2819c29690------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*yWWQgNR2YCYp4LF9bafGbw.jpeg</url>
            <title>Stories by Rafal Kokoszka on Medium</title>
            <link>https://medium.com/@rafikoko?source=rss-2e2819c29690------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 05:04:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@rafikoko/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[How We Optimized Graph Diffing from O(N²) to O(1) in Go]]></title>
            <link>https://medium.com/ifs-tech/how-we-optimized-graph-diffing-from-o-n%C2%B2-to-o-1-in-go-4d233816af77?source=rss-2e2819c29690------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d233816af77</guid>
            <category><![CDATA[performance]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Rafal Kokoszka]]></dc:creator>
            <pubDate>Tue, 17 Feb 2026 05:06:11 GMT</pubDate>
            <atom:updated>2026-02-17T05:06:11.431Z</atom:updated>
            <content:encoded><![CDATA[<p>We have all been there. You are staring at a piece of legacy code you desperately want to refactor. You know it should be safe to change or delete, but you can’t prove it. A full-text search across hundreds of repositories takes hours, and even then, string matching misses the semantic connections. So you leave it. The technical debt stays because the cost of verifying the change is too high.</p><p>This is one of the problem we set out to solve at IFS Labs.</p><p>We asked: <strong>What if we could map every single dependency - across every codebase we own — into a single graph?</strong> And what if that graph was fast enough to tell you, instantly, exactly what breaks if you change a specific function signature?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Gu_oz2XUPgfdiqh7ZVUOHQ.jpeg" /><figcaption>Chaos and order (image generated using Google Nano Banana)</figcaption></figure><p>The challenge isn’t just scale, it is the chaos of the stack. If we were only mapping dependencies within a single repository, standard tools would suffice. But our reality is fractured. We need to trace a lineage from an Outlook add-in written in TypeScript, through a REST API defined in a proprietary DSL, all the way down to a specific object in an Oracle database.</p><p>If we could bridge those architectural gaps in a single, performant graph, the value goes beyond just preventing bugs. Yes, we would know instantly what breaks when a function signature changes. But we could also aggressively identify obsolete APIs and delete dead code that has been haunting the codebase for years because no one knew if it was safe to remove.</p><p>To make that work, standard database queries might be too slow. We needed a pipeline capable of ingesting the chaos — parsing various languages, decoding DSLs, BPM definitions, and reading database schemas — and unifying it all into a single graph. More importantly, we needed a data structure efficient enough to fit millions of these nodes in memory, handle versioning without massive duplication, and diff entire architectures in (milli)seconds.</p><p>This is the story of how we built that engine using a Merkle DAG in Go. It explains why we obsessed over 7-byte padding alignments and why we abandoned standard library features that couldn’t handle the scale. We didn’t optimize for fun — we optimized because we might need to hold the whole world in RAM.</p><p>Here is how we implemented that engine in Go, the trade-offs we accepted, and the optimizations that actually mattered.</p><h3>The Core: Merkle Directed Acyclic Graphs</h3><p>Before we dive into Go structs and benchmark numbers, we need to establish the foundational concept that makes this entire engine work: the <strong>Merkle Directed Acyclic Graph</strong>, or Merkle DAG. The logic is simple but strict:</p><ol><li><strong>Nodes have content-based UIDs.</strong> If the content changes, the UID changes.</li><li><strong>Parents hash their children.</strong> A parent node’s hash is a composite of its data and its children’s hashes.</li><li><strong>Changes bubble up.</strong> Modify a leaf, and you modify its parent, all the way to the root. Its parent’s UID changes, because it includes the child’s UID.</li></ol><p><strong>If two root nodes have the same UID, the trees are identical.</strong> You don’t compare a million nodes; you compare two strings.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NryNMjRLwJDf2loMsFCOsQ.png" /><figcaption>Simple graph (image generated using Google Nano Banana)</figcaption></figure><p>If Leaf 2 changes, Child A changes, and Root changes. Child B remains stable. This structure allows for <strong>structural sharing </strong>— the same mechanism powering Git and IPFS. Our job was simply making it fast in Go.</p><h3>Computing the UID</h3><p>In this system, a “UID” isn’t a random UUID or auto-increment integer. It is a cryptographic signature of the content.</p><p><strong>The formula:</strong></p><pre>UID = SHA256( canonicalJSON(payload) + &quot;|&quot; + canonicalJSON(sorted(childUIDs)) )</pre><p>We use sorted(childUIDs) because insertion order shouldn’t change identity.</p><pre>func (h *sha256Hasher) Hash(payload map[string]any, dependencies []string) (string, error) {<br>    // Create canonical representation of payload<br>    payloadCanonical, err := h.canonicalJSON(payload)<br>    if err != nil {<br>        return &quot;&quot;, err<br>    }<br><br>    // Sort dependencies for consistent ordering<br>    sortedDeps := make([]string, len(dependencies))<br>    copy(sortedDeps, dependencies)<br>    sort.Strings(sortedDeps)<br><br>    depsCanonical, _ := h.canonicalJSON(sortedDeps)<br>    combined := payloadCanonical + &quot;|&quot; + depsCanonical<br><br>    return h.HashString(combined)<br>}</pre><p><strong>The Concept of “BusinessKey”</strong> Before we look at the implications of this hash, we must distinguish between <em>content</em> and <em>identity</em>. A node needs a stable name that persists even when its internals change. We call this the <strong>BusinessKey</strong> — the combination of ComponentType (e.g., &quot;Table&quot;) and Name (e.g., &quot;USERS&quot;).</p><ul><li>The <strong>BusinessKey</strong> answers: “Which node is this?” (Logical Identity)</li><li>The <strong>UID</strong> answers: “What does this node contain right now?” (Physical State)</li></ul><p>This distinction drives two critical behaviors in our engine:</p><ol><li><strong>Change Detection:</strong> When we compare two graph versions, we match nodes by their BusinessKey. If the BusinessKeys match but the UIDs differ, we know the node has been modified.</li><li><strong>Deduplication:</strong> If two nodes have identical content (and thus identical UIDs), they are mathematically the same object. The graph naturally deduplicates itself.</li></ol><p>The 64-character hex string (256-bit SHA-256) becomes the node’s content fingerprint. Every comparison in the diff algorithm ultimately reduces to string equality on these UIDs.</p><h3>Data Structures &amp; Memory Layout</h3><h4>The Node Structure</h4><p>Here is the node structure:</p><pre>type GraphNode struct {<br>    UID             string         `json:&quot;uid&quot;`<br>    ComponentType   string         `json:&quot;componentType&quot;`<br>    Name            string         `json:&quot;name&quot;`<br>    Payload         map[string]any `json:&quot;payload,omitempty&quot;`<br>    <br>    // Native adjacency fields (computed at construction)<br>    ChildUIDs       []string `json:&quot;-&quot;`<br>    BusinessKeyStr  string   `json:&quot;-&quot;`<br>}</pre><p>The UID field holds that content-addressable hash we just discussed. ComponentType and Name together form what we call the <strong>BusinessKey</strong> - the semantic identity of a node that persists across versions even when content changes. When comparing graphs, we match nodes by BusinessKey, then check if their UIDs differ to determine if the content changed.</p><p>The last two fields — ChildUIDs and BusinessKeyStr - exist for performance reasons we&#39;ll cover shortly. They&#39;re computed once at construction time and excluded from JSON serialization (the json:&quot;-&quot; tag).</p><h4>The Edge Structure and Alignment</h4><pre>type GraphEdge struct {<br>    Source      string                 `json:&quot;source&quot;`<br>    Target      string                 `json:&quot;target&quot;`<br>    Label       DependencyType         `json:&quot;label&quot;`<br>    Category    DependencyCategoryType `json:&quot;category,omitempty&quot;`<br>    Importance  uint8                  `json:&quot;importance&quot;`<br>    Metadata    map[string]any         `json:&quot;metadata,omitempty&quot;`<br>}</pre><p>We define Importance as a uint8 (0–100). However, on 64-bit architectures, Go aligns the subsequent Metadata pointer (8 bytes) by adding <strong>7 bytes of padding</strong> after Importance. The struct takes <strong>80 bytes</strong> regardless of whether Importance is uint8 or int</p><p>We kept the padding rather than packing tightly because:</p><ol><li><strong>Type Safety:</strong> uint8 correctly models the domain.</li><li><strong>Future Proofing:</strong> We have 7 bytes of “invisible” space for future small attributes or boolean flags without growing the struct.</li></ol><h3>Solving Adjacency</h3><p>The standard “scan all edges to find children” approach is O(E) per node. In a diff operation, that creates an O(N*E) performance bottleneck:</p><pre>func getChildren(edges []GraphEdge, nodeUID string) []string {<br>    var children []string<br>    for _, edge := range edges {<br>        if edge.Source == nodeUID {<br>            children = append(children, edge.Target)<br>        }<br>    }<br>    return children<br>}</pre><p>To improve, we initially built an adjacency map during the diff:</p><pre>// The naive approach without too much details<br>adjacency := make(map[string][]string)<br>for _, edge := range graph.Edges {<br>    adjacency[edge.Source] = append(adjacency[edge.Source], edge.Target)<br>}</pre><p>This is O(N+E) to build, O(1) to query. But we were building this map <em>every time</em> we ran a diff. For a million-node graph, that’s a million map insertions, each potentially triggering a rehash and reallocation. To be fair, the size of main map could be derived directly from amount of Edges, as we need to collect all targets for each source, but the size of nested slice is harder to handle, as discussed below.</p><p><strong>The Fix: Native Adjacency at Construction</strong></p><p>We moved this cost to the graph build phase. We use a three-pass approach (Index -&gt; Count -&gt; Allocate) to avoid slice growth.</p><ol><li><strong>Index:</strong> Map UIDs to node pointers.</li><li><strong>Count:</strong> Iterate edges to count children per node.</li></ol><p><strong>Allocate:</strong> make([]string, 0, count) and populate. The call pre-allocates exactly the capacity needed, avoiding slice growth reallocations during the append loop.</p><p>Construction takes ~15–70% longer, but child lookups become O(1) pointer reads. For our use case — graphs built once and diffed many times — the amortized cost is negligible.</p><pre>func (dg *DependencyGraph) BuildNativeAdjacency() {<br>    // Phase 1: Build UID -&gt; node pointer<br>    dg.NodeByUID = make(map[string]*GraphNode, len(dg.Nodes))<br><br> // First pass: Build NodeByUID and populate BusinessKeyStr<br> for i := range dg.Nodes {<br>  node := &amp;dg.Nodes[i]<br>  dg.NodeByUID[node.UID] = node<br>  // Pre-compute BusinessKey string using centralized function<br>  node.BusinessKeyStr = FormatBusinessKeyString(node.ComponentType, node.Name)<br>  // Initialize ChildUIDs slice (will be populated in Phase 2)<br>  node.ChildUIDs = nil<br> }<br><br> // Phase 2: Build ChildUIDs from edges<br> // First pass: count children per node for pre-allocation<br> // Use map[string]int only for counting - this is temporary<br> childCounts := make(map[string]int, len(dg.Nodes))<br> for _, edge := range dg.Edges {<br>  childCounts[edge.Source]++<br> }<br><br> // Pre-allocate ChildUIDs slices using direct pointer access via NodeByUID<br> for uid, count := range childCounts {<br>  if node, ok := dg.NodeByUID[uid]; ok {<br>   node.ChildUIDs = make([]string, 0, count)<br>  }<br> }<br><br> // Second pass: populate ChildUIDs using direct pointer access<br> for _, edge := range dg.Edges {<br>  if node, ok := dg.NodeByUID[edge.Source]; ok {<br>   node.ChildUIDs = append(node.ChildUIDs, edge.Target)<br>  }<br> }<br>}</pre><h3>The BusinessKey Cache</h3><p>The BusinessKeyStr field solves a similar problem. During diffing, we align nodes by their business key (type + name). The naive approach:</p><pre>func businessKey(node *GraphNode) string {<br>    return fmt.Sprintf(&quot;%s::%s&quot;, node.ComponentType, node.Name)<br>}</pre><p>fmt.Sprintf allocates a new string every call. At a million nodes compared twice (once per graph), that&#39;s 2 million allocations just for string formatting.</p><p>The fix: compute once, store on the node, even though it might feel inappropriate to store derived value:</p><pre>node.BusinessKeyStr = node.ComponentType + &quot;::&quot; + node.Name</pre><p>One allocation at construction time. Zero at diff time.</p><h3>The Diff Algorithm: Merkle Pruning in Practice</h3><p>Here’s the core of the Merkle diff algorithm — the compareAndPrune function that recursively traverses two graphs: It relies on one axiom: <strong>If UIDs match, stop.</strong></p><pre>func (t *nativeTraverser) compareAndPrune(nodeA, nodeB *graph.GraphNode) {<br>    // THE AXIOM OF PRUNING<br>    // If UIDs are identical, entire subtrees are identical - PRUNE!<br>    if nodeA.UID == nodeB.UID {<br>        return // O(1) - no traversal needed<br>    }<br><br>    // DAG deduplication: avoid processing same pair twice<br>    pair := nodePair{nodeA.UID, nodeB.UID}<br>    if t.visitedPairs[pair] {<br>        return<br>    }<br>    t.visitedPairs[pair] = true<br><br>    // UIDs differ - this node has changed<br>    t.changedNodes = append(t.changedNodes, ChangedNodeInfo{<br>        UID_A:       nodeA.UID,<br>        UID_B:       nodeB.UID,<br>        BusinessKey: graph.BusinessKeyFromGraphNode(*nodeA),<br>        Name:        nodeA.Name,<br>        Type:        nodeA.ComponentType,<br>    })<br><br>    // Get children using native adjacency (O(1) lookup)<br>    childrenA := nodeA.ChildUIDs<br>    childrenB := nodeB.ChildUIDs<br><br>    if len(childrenA) == 0 &amp;&amp; len(childrenB) == 0 {<br>        return<br>    }<br><br>    // Align children by BusinessKey<br>    // childrenAByBK: child nodes from the BASELINE graph (the &quot;before&quot; state)<br>    // childrenBByBK: child nodes from the MODIFIED graph (the &quot;after&quot; state)<br>    childrenAByBK := make(map[string]*graph.GraphNode, len(childrenA))<br>    for _, childUID := range childrenA {<br>        if childNode := t.nodeMapA[childUID]; childNode != nil {<br>            bk := graph.GetBusinessKeyStr(childNode)<br>            childrenAByBK[bk] = childNode<br>        }<br>    }<br><br>    childrenBByBK := make(map[string]*graph.GraphNode, len(childrenB))<br>    for _, childUID := range childrenB {<br>        if childNode := t.nodeMapB[childUID]; childNode != nil {<br>            bk := graph.GetBusinessKeyStr(childNode)<br>            childrenBByBK[bk] = childNode<br>        }<br>    }<br><br>    // Compare: matched children recurse, unmatched are added/removed<br>    for bkStr, childA := range childrenAByBK {<br>        if childB, exists := childrenBByBK[bkStr]; exists {<br>            t.compareAndPrune(childA, childB)  // Recurse on matched pair<br>        } else {<br>            t.markSubtreeRemoved(childA)       // Only in baseline - removed<br>        }<br>    }<br><br>    for bkStr, childB := range childrenBByBK {<br>        if _, exists := childrenAByBK[bkStr]; !exists {<br>            t.markSubtreeAdded(childB)         // Only in modified - added<br>        }<br>    }<br>}</pre><p>The first if statement - if nodeA.UID == nodeB.UID { return } - is where the Merkle optimization efficiency happens. When UIDs match, we&#39;ve mathematically proven that the entire subtree below is identical. No recursion needed. No children to visit. O(1).</p><p>For identical graphs, this means comparing root UIDs and returning immediately — regardless of whether the graph has 100 nodes or 10 million.</p><p>Visual example result of graph diff execution with 3 leaf nodes changed and changes propagating upwards:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4FGNjxy0mkQkloo1v69kCw.png" /></figure><h3>Benchmarks</h3><p>We ran comprehensive benchmarks across graph sizes from tens of nodes to 10 million nodes. All measurements used Go 1.24 on an Intel Core Ultra 7 165U, Windows, with normal GC enabled (no GOGC=off tricks).</p><h4>Memory Footprint</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/990/1*GWxo8h7nVk8pn_7NSjtQcg.png" /></figure><h4>Diff Performance</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/987/1*M7GSrkYAySyR8TO13lAqHQ.png" /></figure><p>The identical-graph case demonstrates the power of content-addressable UIDs: <strong>~350 nanoseconds</strong> to confirm two million-node graphs are identical. That’s comparing root UIDs and returning — no traversal, no allocation beyond the report struct itself.</p><p>The “localized subtree change” scenario shows O(delta) behavior: when one node’s content changes, the algorithm traverses only the path from that node to the root.</p><p>The Zero Overlap (completely different graph) case is our O(N) worst case — when every node has changed, we must visit every node. But even then, 15.9 seconds for a million nodes is roughly 63,000 nodes per second.</p><p>The identical-graph case demonstrates the power of content-addressable UIDs: <strong>~350 nanoseconds</strong> to confirm two million-node graphs are identical. That’s comparing root UIDs and returning — no traversal, no allocation beyond the report struct itself.</p><p>The “localized subtree change” scenario shows O(delta) behavior: when one node’s content changes, the algorithm traverses only the path from that node to the root.</p><p>The Zero Overlap (completely different graph) case is our O(N) worst case — when every node has changed, we must visit every node. But even then, 15.9 seconds for a million nodes is roughly 63,000 nodes per second.</p><h3>Failed Optimizations (What We Abandoned)</h3><h4>1. String Interning</h4><p>UIDs are 64-character hex strings. Each node stores its UID, each edge stores source and target UIDs, and each ChildUIDs slice stores more. The theoretical memory waste from string duplication looked massive - potentially 10+ GB for a 10M node graph.</p><p>We tried two approaches to intern strings:<br><strong>Approach 1: Custom </strong>sync.Map<strong> Pool</strong></p><pre>type UIDInterner struct {<br>    pool sync.Map<br>}<br><br>func (i *UIDInterner) Intern(s string) string {<br>    if existing, ok := i.pool.Load(s); ok {<br>        return existing.(string)<br>    }<br>    i.pool.Store(s, s)<br>    return s<br>}</pre><p><strong>Approach 2: Go 1.23+ </strong>unique<strong> Package</strong></p><pre>import &quot;unique&quot;<br><br>func InternString(s string) string {<br>    return unique.Make(s).Value()<br>}</pre><p>Both approaches <strong>increased memory usage by at least 15–19% at scale</strong>.</p><p>The benchmark data was unambiguous:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/983/1*E3FrEQ6cbp50wM5p7N7nxg.png" /></figure><p>Why: Go already shares backing arrays for string assignments (s2 := s1). Our “optimization” added overhead (map buckets, or unique.Handle bookkeeping) without providing actual deduplication benefit.<br><strong>Lesson:</strong> Profile before optimizing. The Go runtime is smarter than we assumed.</p><h4>2. Lazy Payload Hydration</h4><p>We tried loading JSON payloads only on demand.</p><p>Result: No gain. Our diff logic accesses most payloads anyway to report changes. It just moved the latency curve without lowering it.<br>For workloads with sparse access patterns (e.g., “show me only the changed nodes”), this approach might still provide benefit. It might be also beneficial for us, while enabling loading of detailed payload for UI purposes, without cost of keeping data in memory upfront, but it is potentially a subject of future iteration.</p><h3>Go Runtime observations</h3><h4>1. Map Construction</h4><p>In our initial implementation of BuildNativeAdjacency, we used a temporary map[string]int to map UIDs to slice indices. This doubled the map insertions and allocations during graph construction.</p><p><strong>The Fix:</strong> We refactored the builder to use the primary NodeByUID map (map[string]*GraphNode) immediately. By iterating over the nodes slice and taking pointers &amp;dg.Nodes[i], we could populate the map and then use those pointers to modify the nodes in-place.</p><p><strong>The Impact:</strong> BuildNativeAdjacency Allocations reduced from 231 MB to 175 MB (24% reduction) for 1M nodes by eliminating the intermediate map[string]int index lookup. This is the adjacency-building phase only, not total construction.</p><h4>2. Linear Scan vs. Maps</h4><p>The Go runtime’s map implementation involves hash computation, bucket location, and key comparison. For small N, the constant factors dominate, and a simple for loop with sequential memory access wins on cache locality. <br>While we still need to determine the exact number of elements to draw the line via benchmarking, but we are planning to implement a dual-path in latest algorithm: we iterate the ChildUIDs slice directly rather than building intermediate maps for small N. This dual-path approach ensures optimal performance for both typical (sparse) and edge-case (dense) graph structures.</p><h4>3. The Lazy Unchanged Architecture</h4><p>Our diff algorithm doesn’t explicitly track unchanged nodes. When nodeA.UID == nodeB.UID, we simply return - no allocation, no map insertion, no slice append. Unchanged status is derived lazily via Report.GetNodeDiffState() when callers need it - details not covered in this post</p><h4>4. Pointer vs. Value Semantics</h4><p>map[string]*GraphNode stores 8-byte pointers. map[string]GraphNode copies the entire struct (200+ bytes for our nodes) on every insertion.</p><p>For our node lookup maps, pointers are clearly better</p><h3>Current status</h3><p>The engine handles our current scale requirements. A million nodes diff in about a second for typical big change scenarios. Ten million nodes push into the 25–50 second range — acceptable for batch processing, but interactive use would need further work.</p><p>We deliberately stopped optimizing when the benchmarks met initial requirements to focus on real life use case integration. We will return to optimization path with lessons learnt from practical use case integration</p><h3>Remaining Technical Challenges</h3><p><strong>Parallel traversal vs. GC overhead.</strong> The diff algorithm is inherently tree-recursive, which is worthy to attempt to parallelize execution. Though, it is not trivial. Splitting work across goroutines means synchronizing result collection, and the GC sees more concurrent allocations.</p><p><strong>Very large “completely different” graphs.</strong> When comparing two graphs with zero overlap, we hit O(N) regardless of algorithm cleverness. At 10M nodes, that’s 659 seconds (11 minutes). Streaming result generation — yielding changes as they’re discovered rather than building a complete report — could help for use cases that don’t need the full diff immediately. Smart solutions are needed to optimize performance further.</p><p><strong>Memory under GC pressure.</strong> Peak memory during diff (22.9 GB for 10M “completely different” nodes) includes both graphs plus result data structures. On memory-constrained systems, this might force swapping. Arena-style allocation patterns could help, but Go’s experimental arena package was removed in Go 1.23. Own implementation of this pattern might be considered. Memory optimizations might be required.</p><h3>Join discussion</h3><p>Building this solution has been a journey of continuous learning — about Go’s runtime behavior, about algorithmic trade-offs, and about the gap between theoretical elegance and practical performance.</p><p>We’re still learning. Go’s capabilities (and limitations) continue to surprise us. If you’ve tackled similar problems, if you see optimizations we missed, or if you have questions about our approach — we’d <strong>genuinely</strong> love to hear from you.</p><p>This engine is a work in progress, and the best insights often come from the community.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d233816af77" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ifs-tech/how-we-optimized-graph-diffing-from-o-n%C2%B2-to-o-1-in-go-4d233816af77">How We Optimized Graph Diffing from O(N²) to O(1) in Go</a> was originally published in <a href="https://medium.com/ifs-tech">IFS Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>