<?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 Omer Rosenbaum on Medium]]></title>
        <description><![CDATA[Stories by Omer Rosenbaum on Medium]]></description>
        <link>https://medium.com/@Omer_Rosenbaum?source=rss-75ab88826e85------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*OVnW0K5e2rn1UTcGxYccGQ.jpeg</url>
            <title>Stories by Omer Rosenbaum on Medium</title>
            <link>https://medium.com/@Omer_Rosenbaum?source=rss-75ab88826e85------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 22:38:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@Omer_Rosenbaum/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 Friction Is the Work — Desirable Difficulties in the Age of AI]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/the-friction-is-the-work-desirable-difficulties-in-the-age-of-ai-4c881f48e5fd?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/2400/1*eowebM03UmyclvtFqbAw3w.png" width="2400"></a></p><p class="medium-feed-snippet">A school in Cincinnati got dramatically better results when they took the data dashboards away from teachers and handed them index cards&#x2026;</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/the-friction-is-the-work-desirable-difficulties-in-the-age-of-ai-4c881f48e5fd?source=rss-75ab88826e85------2">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/the-friction-is-the-work-desirable-difficulties-in-the-age-of-ai-4c881f48e5fd?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c881f48e5fd</guid>
            <category><![CDATA[psychology]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[work]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Thu, 04 Jun 2026 11:25:49 GMT</pubDate>
            <atom:updated>2026-06-04T11:25:49.838Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Git Bisect: How to Find a Faulty Commit Fast]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/git-bisect-how-to-find-a-faulty-commit-fast-4d6e3243e73e?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/602/1*i2ixzSIQu6b6l5IsOPexzA.png" width="602"></a></p><p class="medium-feed-snippet">I would like to introduce one of Git&#x2019;s awesome tools that allows you to quickly find a faulty commit &#x2014; git bisect.</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/git-bisect-how-to-find-a-faulty-commit-fast-4d6e3243e73e?source=rss-75ab88826e85------2">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/git-bisect-how-to-find-a-faulty-commit-fast-4d6e3243e73e?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d6e3243e73e</guid>
            <category><![CDATA[git-bisect]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Sun, 01 Mar 2026 08:40:27 GMT</pubDate>
            <atom:updated>2026-03-17T12:09:38.987Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Stop Staring at a Blank Deck — How I Use Claude Code + Marp to Think Through Presentations]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://overcast.blog/stop-staring-at-a-blank-deck-how-i-use-claude-code-marp-to-think-through-presentations-74bb95ec67d3?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/2000/0*HHy7-RCRF_oS8WeU.png" width="2000"></a></p><p class="medium-feed-snippet">(I used a deck to think through this post, you can find it here)</p><p class="medium-feed-link"><a href="https://overcast.blog/stop-staring-at-a-blank-deck-how-i-use-claude-code-marp-to-think-through-presentations-74bb95ec67d3?source=rss-75ab88826e85------2">Continue reading on overcast blog »</a></p></div>]]></description>
            <link>https://overcast.blog/stop-staring-at-a-blank-deck-how-i-use-claude-code-marp-to-think-through-presentations-74bb95ec67d3?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/74bb95ec67d3</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[markdown]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Thu, 26 Feb 2026 15:13:44 GMT</pubDate>
            <atom:updated>2026-03-19T13:05:06.766Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The R in R&D]]></title>
            <link>https://overcast.blog/the-r-in-r-d-bb090adfb938?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb090adfb938</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[research-and-development]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Tue, 12 Nov 2024 09:13:15 GMT</pubDate>
            <atom:updated>2025-01-07T11:07:04.764Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*90JAMCJL5HDBl9yLzooHHw.png" /></figure><p>Most organizations have a Research and Development department, or R&amp;D. Within software organizations, R&amp;D departments are made up of developers, or engineers, and have clear goals to accomplish that are usually represented in a task management system (like Jira). Developers (or engineers) write, test, and deploy code.</p><p>But what about the R of R&amp;D? There appears to be some ambiguity here. Some argue that every developmental task includes an element of “research” — you need to test your code and potentially explore various approaches.</p><p>So is this Research?</p><p>I am less focused on semantics here. However, many individuals can distinguish between the process of a development task (involving trial and error, reviewing others’ code, and more) and “deep” research — where the individual encounters a problem without a clear solution.</p><p>All software organizations have Development tasks, but with Research it varies. Some organizations have a lot of Research tasks, while others have none. There are even organizations with dedicated Research teams, and in others, only a select few are ever assigned these mystical tasks.</p><p>So what is really Research in R&amp;D organizations? Is it a skill that can be learned, or is it something that is a bit more “exclusive”?</p><p>In this series, we will dive into these questions, and consider various aspects of solving Research problems.</p><h3>A working definition of research tasks</h3><p>For the purpose of this article, let’s adopt the following working definition for “Problem Solving” by Alan H. Schoenfeld:</p><p>“You are engaged in Problem Solving when you are trying to achieve something, and you do not know a straightforward way to do so.”</p><p>For example, calculating 9481759*201471 may not qualify as Problem Solving (for someone who learned how to do it, and I assume you did). It’s not easy, it’s time consuming and error-prone, but at the end of the day, it’s not Problem Solving.</p><p>When you encounter a math problem without a clear solution or face a blank page while attempting to write an essay, you are engaging in problem-solving. It’s about figuring out the best approach, whether it’s tackling numbers or crafting words.</p><p>Many Development tasks involve Problem Solving: you need to think about how to implement a specific function, or browse through code to try and find a hint as to why something works the way it does.</p><p>Many D(evelopment) tasks involve Problem Solving — you need to think about how to implement a function, or browse through the code for a hint to how something is working. Yet, if you are thinking about the implementation of something you know can be implemented, I will not consider it as R(esearch). It is a R(esearch) task, when you simply do not know how to proceed — what to look for, and whether the path you are pursuing can even produce a relevant solution.</p><p>Throughout these posts, I will relate to such tasks, and the “R” in R&amp;D in general, as “Research” (with a capital R).</p><h3>A true story</h3><p>It was a hot summer day in Atlanta, Georgia and I was at the Render conference with the Swimm team.</p><p>I had an idea: draw attendees to our booth with a problem, “wrapped” as a game, that included a prize. Anyone could attempt to solve the problem and win. And if they did, they would receive one of our classic Swimm rubber ducks.</p><p>You can see the game from the original booth here:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/932/0*dsFK_hZfimwrpr-2" /></figure><p>In the image above, the duck is on spot number 41. On each player’s turn, they can move the duck between 1 to 6 spots. For example, if the duck is on spot 41, the player can move it to any spot between 40 and 35. The player who moves the duck to spot 1 wins the game.</p><p>Anyone who approached the booth could play. They had the choice to play first or second, and could take as much time as they needed to think. I played against them, and if they won, they would get the duck.</p><p>None of the players won on their first try. Many attempted multiple times but still failed. At that point, they didn’t know what to do. It wasn’t obvious to them that there <em>was</em> a solution (until I told them), or how to approach the problem.</p><p>In a way, this is like a small research task.</p><p>Some people came back after a few attempts and solved the puzzle. Most didn’t — they just gave up. It’s hard to say whether they weren’t motivated enough to succeed or didn’t believe they could. Still, many questions arise: What separated those who succeeded from those who didn’t? More importantly, is this a natural ability, or can people improve their problem-solving skills?</p><p>We will return to this puzzle and solve it later in this post.</p><h3>Is research something you can “learn”?</h3><p>People aren’t born with the ability to solve the game I just described. In my experience, here are three ways one could go about improving their Research skills:</p><h3>1. While solving real tasks</h3><p>When you encounter real research tasks — whether at work or elsewhere — you may succeed, fail, and learn from your attempts. For some, this might seem like the <em>only</em> way to improve research skills. Indeed, this approach has its advantages. Nothing is as effective as learning by doing, and tackling difficult research tasks can significantly enhance your skills.</p><p>However, consider the downsides of this method. First, it takes a lot of time. Complex research tasks can span months or even years. But an even bigger challenge is that when you’re assigned a research task, you often don’t know how difficult it is — neither does your boss or the person who gave you the task. They may <em>estimate</em> the level of difficulty, but they can’t <em>know</em> for sure. The task might be unsolvable, or it might only be solvable by someone with much more experience than you. Is the best way to learn math to be suddenly confronted with a 10th-grade problem when you’re only in 3rd grade? Probably not.</p><h3>2. Learning from others’ research</h3><p>Learning from more experienced researchers — whether by watching their talks or reading their research diaries (more on that later) — is certainly faster than learning solely by doing. You can gain insights from others that you might never discover on your own. However, there’s a limit to how much you can absorb from someone else’s research. Ultimately, personal experience plays a crucial role in deepening your understanding and honing your skills.</p><h3>3. Gradual, focused &amp; guided problems</h3><p>For example, if you take a “research course” where you’re given bite-sized puzzles to solve, you can dedicate time to solving them with the reassurance that each puzzle is solvable and appropriate for your current skill level. Afterward, you can discuss the problem with peers or an instructor and receive feedback on your solution. This approach allows you to gradually improve your research skills in a structured way. However, having access to such a course isn’t always feasible, and learning from these controlled problems isn’t quite the same as tackling “real” research tasks.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/817/0*ojEaceSK8byAM7tG" /></figure><p>Actually, the most effective way is probably some combination of the three. You can’t learn to swim without getting into the water, but you can learn a lot about swimming by watching others swim, or by practicing in a controlled environment.</p><h3>Back to the game</h3><p>As I mentioned earlier, most people who encountered this challenge didn’t know how to approach the problem and eventually gave up. You might wonder, what does this game have to do with research? After all, it’s just a simple game, not a research task, right?</p><p>In the next section, I’ll introduce a framework for problem-solving that I believe can be applied to research tasks. We’ll analyze the Spiral game using this framework and explore how it can be applied to more complex problems.</p><p>But first, let’s solve the puzzle. If you’re up for it, give it a try — can you figure out a strategy to ensure you always win?</p><h3>The game: solution</h3><p>Let’s tackle the solution methodically: it would be much easier to start from the end.</p><p>Let’s think about this methodically.</p><p>It would be much easier to start from the end:</p><ul><li>Let’s say the duck is on spot `2`, we would want to move it `1` step. That’s clear</li><li>What about `3`? Move `2` steps. Thats’ clear too.</li><li>We can keep going this way until we get to `7`, where we need to take `6` steps.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/822/0*2dXba8HucjcHZBfe" /></figure><p>What happens if we find ourselves on spot `8`?</p><p>If we were to take `1` step, our openent will have their duck on spot `7` and we know that means they could win. For every possible turn, we can see that if the duck is on spot `8`, the player who moves first will move to duck to a position between `2` and `7`, where the other player can win.</p><p>Since there is no “good” move for the player who moves first when the duck is on spot `8`, we would want to be the second player in that case.</p><p>Now, we can also look at it as a new game, where the player who reached `8` first wins.</p><p>Now, we can look at it as a new game — the player who reaches `8` wins. If we move the duck to spot `8`, then it’s the other player’s turn, and we know for certain that we can win. Therefore, we should <em>only</em> focus on reaching spot `8`.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/829/0*X3Q_uhnhptzdKA_I" /></figure><p>Let’s keep going</p><p>So, let’s keep going. If the duck is on spot `9` — we can take `1` step and get to `8`, wishing to be first. If the duck is on spot `10` — we can take `2` steps and get to `8`.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/785/0*cdsahC8MF0jbfpfd" /></figure><p>And so on…</p><p>Until we get to `14`, where we need to take `6` steps to get to `8`.</p><p>At spot `15`, any move we make would leave the duck between spots `9` and `14`, where we already know we want to be the first player. Therefore, if the duck is on spot `15`, we would want to be the second player.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/799/0*_nWA1SmUvbT3d6z2" /></figure><p>And now — once again — we can consider this a new game: reaching `15` to win.</p><p>`8` and `15` are exactly `7` spots apart. This is no coincidence. It is the same difference between `1` and `8`, and we win when we get to `1`. When a player has to play on spot `8`, they can move at max `6` steps which is not enough to reach `1`, and then the other player can make the move to reach `1`.</p><p>In general, if we keep the following we always win:</p><p>After each turn we make, the duck will be on a spot of the form `7k+1` (where `k` is a non-negative integer). So `1`, `8`, `15`, `22`, `29` and so on — are all spots where we want to be second.</p><p>(You can find a formal and complete “proof” — in the appendix)</p><p>So, what can we take from this puzzle? Let us consider a framework for solving problems first.</p><h3>Framework for problem solving</h3><p>I would like to adopt a framework for Problem Solving by Alan H. Schoenfeld (1992, see references). While this framework was first devised to describe how people solve math problems, I believe it can be applied to Research tasks in general.</p><p>In his paper, Schoenfeld describes the components of Problem Solving**</p><ol><li><strong>The knowledge base</strong>: This is what <em>you</em> <em>know. </em>For example, when faced with an optimization problem, are you familiar with profiling tools and optimization algorithms? Do you know how to use them?</li><li><strong>Heuristics:</strong> These are the <em>strategies</em> you can use to solve problems. For example, when faced with an optimization problem, you can try to profile your code to see where bottlenecks exist. You can also debug a specific use case, or draw a diagram of the problem. If the problem you are solving is writing a compelling article, heuristics can be creating an outline before starting to write, using a specific structure, or writing the conclusion first.</li><li><strong>Control: </strong>The ability to <em>monitor progress</em>, and adjust your strategy if needed. For example, if you’re trying to solve a problem and you see that your strategy isn’t working, try a different approach. This is what distinguishes experienced engineers from novices. What matters isn’t just what you know, but how and when you decide to use that knowledge.</li><li><strong>Beliefs and attitudes:</strong> These are <em>your beliefs</em> about your ability to solve the problem. For example, if you don’t believe you can solve an optimization problem, you may not even tackle it in the first place. In Schoenfeld’s research, he describes the beliefs of students when it comes to math problems, like “I’m not good at math”, “math is a matter of memorization, “there is one right answer”, and the list goes on. These beliefs can greatly affect your ability to solve problems.</li></ol><h3>Applying Schoenfeld’s framework to the Spiral game</h3><ol><li><strong>The knowledge base</strong>: In order to solve the game, you need to know how to add and subtract numbers. But, to prove that you always can win, you need to understand “modulus” — that is the remainder of a division.</li><li><strong>Heuristics</strong>: We mainly used three heuristics to solve this problem. First, we tried to solve the problem by starting from the end and working back. Second, we considered cases systematically and listed them. Third, we generalized the solution to all cases.</li><li><strong>Control</strong>: I provided a clear solution to the problem, but most people initially approach it by making various “guesses.” For example, they might think, “Maybe I just need to be first on odd-numbered spots.” When they test this hypothesis, a form of Control is to find a counterexample that disproves it. Understanding that you should start from the end, work backwards, and approach the problem systematically — using the heuristics described earlier — is also a form of Control. This helps to refine and focus their approach, leading to a more effective solution.</li><li><strong>Beliefs and attitudes: </strong>If you believe that you can solve the problem, you’re more likely to try. Many of those who tried, simply gave up after a few minutes, usually accompanied with a shrug and saying something like “I’m not so good at these kinds of things.” Another belief is that you should solve this problem in your head, rather than using a pen and paper. To systematically consider different spots, it is actually very helpful to write them down.</li></ol><p>** Actually, Schoenfeld (1992) described five components (which he terms “categories”), but I focused on four of them.</p><h3>Learning to research</h3><p>So, again, what does the Spiral Game have to do with Research?</p><p>The same <strong>Heuristics</strong> and <strong>Control</strong> we used to solve the Spiral Game can be applied to more complex Research tasks. The <strong>Knowledge base </strong>would probably be different. By solving tasks like this, talking about how you solved them, and learning from that experience, you can improve your research skills. It doesn’t happen overnight but with practice on many problems. I’ve seen people get better by starting with small challenges and working their way up to harder ones. Research by Schoenfeld shows that people can learn to use smart strategies for problem-solving and can also learn to track their progress and adjust their approach (Control) as they go.</p><p>The next posts in this series will discuss additional common heuristics in problem solving, and how one may acquire them by tackling more complex problems.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb090adfb938" width="1" height="1" alt=""><hr><p><a href="https://overcast.blog/the-r-in-r-d-bb090adfb938">The R in R&amp;D</a> was originally published in <a href="https://overcast.blog/">overcast blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Documenting Microservices in 2024]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://overcast.blog/documenting-microservices-in-2024-fa544af60d16?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/2600/1*FvBGunhOaX35vgJimstb6Q.jpeg" width="6000"></a></p><p class="medium-feed-snippet">Moving from a monolithic architecture to microservices is scary &#x1F631;, with many opportunities for things to go wrong. You might be wondering&#x2026;</p><p class="medium-feed-link"><a href="https://overcast.blog/documenting-microservices-in-2024-fa544af60d16?source=rss-75ab88826e85------2">Continue reading on overcast blog »</a></p></div>]]></description>
            <link>https://overcast.blog/documenting-microservices-in-2024-fa544af60d16?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/fa544af60d16</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Thu, 29 Aug 2024 14:34:23 GMT</pubDate>
            <atom:updated>2024-08-29T14:34:23.682Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Modernizing Legacy Code: It Starts with Understanding]]></title>
            <link>https://overcast.blog/modernizing-legacy-code-it-starts-with-understanding-6271b04beae9?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/6271b04beae9</guid>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Wed, 17 Jul 2024 12:48:23 GMT</pubDate>
            <atom:updated>2024-07-18T20:54:12.678Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OYFgDy0Qw3HThPWPRP23iA.jpeg" /></figure><p>Modernizing software systems is a top priority for many organizations. Despite being considered outdated, legacy software remains widely used, with billions of lines of code still in operation decades later. The world of legacy software continuously evolves and expands, incorporating new programming languages.</p><p>Modernization means different things to different people. For some, it involves a complete system rewrite, while others see it as refactoring the current codebase for better maintainability. Some view modernization as integrating new features into an existing system.</p><p>In this post, we explore the concept of modernization, emphasizing the importance of thoroughly understanding your current codebase to <a href="https://swimm.io/modernize-legacy-code">successfully modernize legacy code</a>. We also provide practical tips on how to achieve this effectively.</p><h3>The process of modernizing legacy code</h3><p>So you have a large, complex system, and chances are you’re not modernizing it out of boredom. Specific reasons or an accumulation of them typically drive the need for modernization. These reasons might include adding new features, improving performance, or making the system more maintainable due to persistent production bugs.</p><p>Regardless of your reasons, the first step is to understand the codebase to some extent. This understanding helps you determine what needs to change and how to approach it. Should you rewrite it entirely? When adding a new feature, how much effort will it require within the current system? If the goal is to enhance performance, where are the bottlenecks?</p><p>After you gain a sufficient understanding of the codebase, you can decide to either:</p><ol><li>Rewrite the system (or parts of it)</li><li>Maintain and possibly extend or patch the existing system</li></ol><h3>Understanding legacy codebases</h3><p>If you decide to rewrite the system, you must understand the existing system to know what to change and how. During the rewrite, you’ll need to delve deeper into specific parts and ensure that knowledge about the new system remains clear.</p><p>If you choose to maintain the system, you’ll need to know the existing system well enough to identify what and how to change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/996/1*oWyEh5d7fxvzRDuDe-5pfQ.png" /></figure><p>In either case, understanding the system is crucial for successful modernization. This step is often overlooked, but it’s vital to thoroughly know your codebase before deciding whether to rewrite or maintain it. The challenge lies not only in assigning someone to comprehend the code but also in understanding a legacy system, which is inherently complex</p><h3>Why is modernizing legacy so hard?</h3><p>Understanding code is always challenging, but understanding legacy code is particularly difficult. Here’s why:</p><h4>1. Programming languages used</h4><p>Legacy systems often utilize outdated programming languages that are no longer widely used. Few developers are familiar with these languages, and even fewer are willing to work with them. Additionally, these languages are known for being challenging to work with, lacking key features like strong typing, garbage collection, and object-oriented programming that modern developers rely on.</p><p>Legacy programming languages designed in the latter half of the 20th century continue to dominate certain domains, such as the financial sector, and maintain a significant presence in other critical areas like insurance, logistics, manufacturing, and the military. Even in the <a href="https://www.tiobe.com/tiobe-index/">programming community index TIOBE</a>, languages like COBOL (#19) and FORTRAN (#9) are constantly looming next to modern freshly designed and regularly updated languages like Rust (#13), Ruby (#14) or Kotlin (#20). According to a recent survey by <a href="https://www.opentext.com/en-gb/what-is/cobol">Micro Focus (2022)</a>, approximately 800 billion lines of COBOL code are used in production every day.</p><p>Compounding the challenge, these legacy languages have numerous variations or dialects. For example, <a href="https://doi.org/10.1109/52.965809">there are approximately 300 dialects of COBOL currently in use</a>.</p><h4>2. Complexity of the codebase</h4><p>Legacy codebases are often large and complex, with many interdependencies between different parts of the system. This complexity makes it difficult to understand the system’s overall functionality and predict the impact of changes.</p><h4>3. The people who wrote the code are gone</h4><p>Since most of the code was written a long time ago, the people who know it the best are rarely available to answer questions or provide any sort of explanation.</p><h3>Here’s how to understand legacy code</h3><p>By now, we’ve established why understanding legacy code is an essential first step in any modernization effort. But, how do you go about understanding your codebase? Here are some practical tips:</p><h4>1. Automatic tools</h4><p>There are a number of tools out there that can help you understand your codebase and help you get started on your modernization journey. One example is Swimm, specifically the Auto-docs feature. Swimm generates overview documentation for an entire repository in just one click. This documentation exposes complex flows and patterns along with hidden components and entities in the codebase and gives you a head start on the understanding process.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FLbn95qxoymA%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DLbn95qxoymA&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FLbn95qxoymA%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a6a0459ea71eb996f9a50a4f4697fbeb/href">https://medium.com/media/a6a0459ea71eb996f9a50a4f4697fbeb/href</a></iframe><h4>2. Different personas, different stages of the understanding process</h4><p>Different types of documentation would help different people at different stages of the understanding process. For example, say you need to modify a specific flow in your system. A high level document about the system’s flows should help you find the flow you are looking for. Then, a high level description of this flow should allow both the product owner as well as the engineer to understand what the flow does and have a shared language when discussing this flow. Lastly, a detailed description of the flow should help the engineer understand the flow well enough to make the necessary changes, and even before that — estimate the effort required to make the changes.</p><h4>3. Document as you go</h4><p>Automatic tools will only get you so far. To truly understand your codebase, you need to work with it, play with it, and make changes. While you do that, create documentation based on what you learn. This will help you remember what you’ve learned and share it with others.</p><p>One simple method to create documentation while coding is by utilizing Swimm’s Snippets2Doc feature. Just select code snippets and Swimm will generate an extensive and accurate document for you. This provides detailed and concise documentation without the need for significant time and resources typically required for manual documentation creation.</p><h4><strong>4. Up-to-date and accessible documentation</strong></h4><p>Documentation has little value if it’s not maintained. Without updating documentation, you’ll be back to square one really quickly — without a single trustworthy resource to rely on when engineers or other technical members of your team need to understand your codebase.</p><p>Swimm’s Auto-sync keeps documentation up to date automatically as part of your CI, recognizing code changes and updating documentation accordingly.</p><h3>Conclusion</h3><p>Modernizing legacy systems and code is a complex yet critical task for many software organizations. And although modernization projects vary in scope and scale, they all require the same starting point: thoroughly understanding the existing codebase.</p><p>Tools like <a href="http://www.swimm.io/">Swimm</a> really help this process by providing automatic documentation that uncovers intricate flows and hidden components within your codebase. By using these tools, following a documentation-as-you-go approach, and ensuring up-to-date documentation, organizations can better tackle the challenges of legacy systems. Ultimately, a well-understood codebase is key to successful modernization.</p><figure><a href="https://buymeacoffee.com/omerr"><img alt="" src="https://cdn-images-1.medium.com/max/966/0*IPZojW0QRLDqLv4V.png" /></a><figcaption>If you’ve enjoyed this post, I would really appreciate a coffee 🙏🏻</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6271b04beae9" width="1" height="1" alt=""><hr><p><a href="https://overcast.blog/modernizing-legacy-code-it-starts-with-understanding-6271b04beae9">Modernizing Legacy Code: It Starts with Understanding</a> was originally published in <a href="https://overcast.blog/">overcast blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git UNDO — how to rewrite Git history with confidence]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/git-undo-how-to-rewrite-git-history-with-confidence-d4452e2969c2?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/600/0*OopxPbiQh6rpTOi_.png" width="600"></a></p><p class="medium-feed-snippet">As a developer, your work with Git all the time.</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/git-undo-how-to-rewrite-git-history-with-confidence-d4452e2969c2?source=rss-75ab88826e85------2">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/git-undo-how-to-rewrite-git-history-with-confidence-d4452e2969c2?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/d4452e2969c2</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Fri, 21 Apr 2023 15:16:29 GMT</pubDate>
            <atom:updated>2024-07-18T20:55:20.541Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Will Copilot For Docs Replace Internal Documentation?]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://javascript.plainenglish.io/will-copilot-for-docs-replace-internal-documentation-7c3294b1bb1f?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/1068/0*8Xf4EeN2Cgbavf0K" width="1068"></a></p><p class="medium-feed-snippet">Generative AI and ChatGPT have created a lot of buzz, sparking discussions about how and if this technology can replace other tasks or&#x2026;</p><p class="medium-feed-link"><a href="https://javascript.plainenglish.io/will-copilot-for-docs-replace-internal-documentation-7c3294b1bb1f?source=rss-75ab88826e85------2">Continue reading on JavaScript in Plain English »</a></p></div>]]></description>
            <link>https://javascript.plainenglish.io/will-copilot-for-docs-replace-internal-documentation-7c3294b1bb1f?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/7c3294b1bb1f</guid>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[devtools]]></category>
            <category><![CDATA[documentation]]></category>
            <category><![CDATA[internal-documentation]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Wed, 05 Apr 2023 09:06:49 GMT</pubDate>
            <atom:updated>2023-04-05T09:06:49.373Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[A Visualized Intro to Git Internals — Objects and Branches]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/swimm/a-visualized-intro-to-git-internals-objects-and-branches-68df85864037?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/600/1*4nBU4Vx4cYvX3Yw49WtjsA.png" width="600"></a></p><p class="medium-feed-snippet">Many of us use git on a daily basis. But how many of us know what goes on under the hood? For example, what happens when we use git commit&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/swimm/a-visualized-intro-to-git-internals-objects-and-branches-68df85864037?source=rss-75ab88826e85------2">Continue reading on Swimm »</a></p></div>]]></description>
            <link>https://medium.com/swimm/a-visualized-intro-to-git-internals-objects-and-branches-68df85864037?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/68df85864037</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[git-internals]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Mon, 27 Apr 2020 06:24:02 GMT</pubDate>
            <atom:updated>2024-07-18T20:55:51.749Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Getting Hardcore — Creating a Repo From Scratch]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/swimm/getting-hardcore-creating-a-repo-from-scratch-cc747edbb11c?source=rss-75ab88826e85------2"><img src="https://cdn-images-1.medium.com/max/600/1*y9qUJM56oI5bXKmCOFTGCg.png" width="600"></a></p><p class="medium-feed-snippet">A Hands-On Intro to Git Internals</p><p class="medium-feed-link"><a href="https://medium.com/swimm/getting-hardcore-creating-a-repo-from-scratch-cc747edbb11c?source=rss-75ab88826e85------2">Continue reading on Swimm »</a></p></div>]]></description>
            <link>https://medium.com/swimm/getting-hardcore-creating-a-repo-from-scratch-cc747edbb11c?source=rss-75ab88826e85------2</link>
            <guid isPermaLink="false">https://medium.com/p/cc747edbb11c</guid>
            <category><![CDATA[computer-sc]]></category>
            <category><![CDATA[git]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[code]]></category>
            <category><![CDATA[git-internals]]></category>
            <dc:creator><![CDATA[Omer Rosenbaum]]></dc:creator>
            <pubDate>Mon, 27 Apr 2020 06:22:15 GMT</pubDate>
            <atom:updated>2024-07-18T20:56:01.352Z</atom:updated>
        </item>
    </channel>
</rss>