{"id":7295,"date":"2025-03-06T09:52:56","date_gmt":"2025-03-06T09:52:56","guid":{"rendered":"https:\/\/algocademy.com\/blog\/from-code-reader-to-creator-breaking-the-blank-page-barrier\/"},"modified":"2025-03-06T10:14:42","modified_gmt":"2025-03-06T10:14:42","slug":"from-code-reader-to-creator-breaking-the-blank-page-barrier","status":"publish","type":"post","link":"https:\/\/algocademy.com\/blog\/from-code-reader-to-creator-breaking-the-blank-page-barrier\/","title":{"rendered":"Why You Understand The Code But Can’t Write It From Scratch"},"content":{"rendered":"

The Coding Comprehension Paradox: Understanding vs. Creating<\/h2>\n

Have you ever found yourself nodding along while reading someone else’s code, thinking “This makes perfect sense!” \u2014 only to freeze when faced with a blank editor and asked to create similar functionality from scratch? This phenomenon is incredibly common, even among experienced developers. You’re not alone in this struggle, and there’s actually solid cognitive science behind why understanding code and generating it are such different mental processes.<\/p>\n

This disconnect between comprehension and creation is what I call the “Coding Comprehension Paradox,” and it affects programmers at all levels. In this post, we’ll explore why recognizing patterns in existing code is fundamentally different from conjuring solutions from thin air, and more importantly, how you can bridge this gap in your own development journey.<\/p>\n

Recognition vs. Recall: The Fundamental Cognitive Difference<\/h2>\n

At its core, this problem stems from how our brains process information. Cognitive psychologists distinguish between two types of memory retrieval: recognition and recall.<\/p>\n

Recognition memory<\/strong> is your ability to identify information you’ve previously encountered. When reading code, you’re essentially saying, “Yes, I recognize this pattern. I know what a for-loop does. I understand how this function transforms data.”<\/p>\n

Recall memory<\/strong>, on the other hand, requires you to retrieve information from memory without external cues. Writing code from scratch demands recall \u2014 you must summon syntax, algorithms, and patterns with minimal prompting.<\/p>\n

This distinction explains why you might perfectly understand every line of a complex algorithm when reading it, but struggle to reproduce even a simplified version when staring at an empty file. Recognition is simply easier for our brains than recall.<\/p>\n

Think of it like the difference between recognizing a friend’s face in a crowd (easy) versus trying to draw their portrait from memory (much harder). Both involve the same information, but the mental processes are vastly different.<\/p>\n

The Four Stages of Code Comprehension<\/h2>\n

To better understand this paradox, let’s break down the journey from reading code to writing it:<\/p>\n

1. Passive Familiarity<\/h3>\n

At this stage, code looks familiar. You recognize syntax, understand what individual lines do, and can follow the general flow. This is where many developers get stuck thinking they “understand” the code.<\/p>\n

For example, you might look at this JavaScript snippet and understand it perfectly:<\/p>\n

const users = [\n  { name: 'Alice', age: 25, active: true },\n  { name: 'Bob', age: 30, active: false },\n  { name: 'Charlie', age: 35, active: true }\n];\n\nconst activeUsers = users.filter(user => user.active);\nconsole.log(activeUsers);<\/code><\/pre>\n
You recognize the array, the objects within it, the filter method, and the arrow function. It all makes sense when you read it.<\/p>\n
2. Active Comprehension<\/h3>\n
Here, you can not only read the code but also explain it to someone else, predict its output, and identify potential edge cases or bugs. You understand not just what the code does, but why it’s written that way.<\/p>\n
Using our example above, at this stage you could explain that the code filters an array of user objects to include only those with the “active” property set to true, and you might even point out that the code doesn’t handle cases where the “active” property might be missing.<\/p>\n
3. Adaptation Ability<\/h3>\n
At this level, you can take existing code and modify it to suit different requirements. You can change parameters, add features, or fix bugs. This is where many professional developers operate day-to-day.<\/p>\n
For instance, you could adapt the previous example to filter users who are both active and over a certain age:<\/p>\n
const activeAdultUsers = users.filter(user => user.active && user.age >= 18);\nconsole.log(activeAdultUsers);<\/code><\/pre>\n
4. Generation Capability<\/h3>\n
This is the ability to create similar functionality from scratch without referencing existing code. It requires deep internalization of patterns, principles, and problem-solving approaches.<\/p>\n
At this stage, if asked to “write code that filters a collection based on certain criteria,” you could produce a solution without looking at examples.<\/p>\n
The gap between stages 3 and 4 is where most developers experience the frustration of understanding but not being able to create.<\/p>\n
Why Understanding Code Doesn’t Automatically Enable Creation<\/h2>\n
Several factors contribute to the disconnect between comprehension and creation:<\/p>\n
The Illusion of Competence<\/h3>\n
When we read well-written code, its clarity can create an illusion that we’ve mastered the concepts. Psychologists call this “fluency bias” \u2014 when information feels easy to process, we assume we’ve learned it thoroughly. But true learning requires active engagement, not just passive reading.<\/p>\n
Think about learning a foreign language: understanding a sentence when you hear it is much easier than constructing grammatically correct sentences yourself. The same principle applies to code.<\/p>\n
Working Memory Limitations<\/h3>\n
Writing code from scratch requires juggling multiple concepts simultaneously in your working memory:<\/p>\n
    \n
  • Syntax details<\/li>\n
  • Algorithmic approach<\/li>\n
  • Variable naming and management<\/li>\n
  • Program flow and structure<\/li>\n
  • Edge cases and error handling<\/li>\n<\/ul>\n
    Our working memory has limited capacity (typically 4-7 items). When reading code, the structure is provided for you, reducing cognitive load. When writing code, you must manage all these elements yourself, which can quickly overwhelm your mental resources.<\/p>\n
    The Missing Context<\/h3>\n
    Existing code provides context and constraints that guide understanding. It’s like having the border and corner pieces of a puzzle already assembled. Without this framework, the blank editor represents infinite possibilities, which can be paralyzing.<\/p>\n
    Additionally, professional codebases often contain layers of context that aren’t immediately visible:<\/p>\n
      \n
    • Architecture decisions made before this code was written<\/li>\n
    • Team conventions and patterns<\/li>\n
    • Historical reasons for certain approaches<\/li>\n
    • Implicit knowledge about the problem domain<\/li>\n<\/ul>\n
      When trying to write similar code, you may be missing this crucial context.<\/p>\n
      The Gap Between Conceptual and Procedural Knowledge<\/h3>\n
      Understanding code (conceptual knowledge) is different from knowing the steps to create it (procedural knowledge). This is similar to understanding how a car works versus knowing how to build one.<\/p>\n
      You might perfectly understand what a binary search tree is and how it functions, but implementing one requires procedural knowledge of:<\/p>\n
        \n
      • How to define the node structure<\/li>\n
      • How to write insertion logic<\/li>\n
      • How to implement traversal algorithms<\/li>\n
      • How to handle edge cases<\/li>\n<\/ul>\n
        Each of these steps requires its own procedural knowledge, creating a much higher barrier to creation than comprehension.<\/p>\n
        The Role of Experience and Pattern Recognition<\/h2>\n
        Experienced developers seem to magically produce code because they’ve internalized common patterns and solutions. This pattern recognition develops through repeated exposure and practice.<\/p>\n
        When a senior developer writes code “from scratch,” they’re actually assembling pre-existing mental patterns they’ve built over years. They’re not creating entirely new solutions each time.<\/p>\n
        Mental Models and Chunking<\/h3>\n
        Experts use what psychologists call “chunking” to overcome working memory limitations. Instead of thinking about individual lines of code, they think in higher-level patterns or “chunks.”<\/p>\n
        For example, an experienced developer doesn’t see this:<\/p>\n
        for (let i = 0; i < array.length; i++) {\n    if (array[i].property === value) {\n        return array[i];\n    }\n}\nreturn null;<\/code><\/pre>\n
        They see \"find first matching element in array\" as a single concept or chunk. This mental compression allows them to hold more complex ideas in working memory.<\/p>\n
        As you gain experience, you develop more sophisticated chunks, enabling you to think at higher levels of abstraction. This is why experienced developers can write complex functionality quickly \u2014 they're not thinking about each line, but about larger conceptual units.<\/p>\n
        The Importance of Deliberate Practice<\/h3>\n
        Building these mental models requires deliberate practice \u2014 not just reading or writing code, but consciously analyzing patterns and internalizing them. This is why simply reading more code won't necessarily improve your ability to write it.<\/p>\n
        Research in expertise development shows that the quality of practice matters more than quantity. Effective practice involves:<\/p>\n
          \n
        • Working at the edge of your abilities<\/li>\n
        • Receiving immediate feedback<\/li>\n
        • Reflecting on what worked and what didn't<\/li>\n
        • Deliberately practicing difficult components<\/li>\n<\/ul>\n
          This type of focused practice builds the neural pathways needed for effective recall when writing code from scratch.<\/p>\n
          Bridging the Gap: Strategies to Improve Your Code Creation Skills<\/h2>\n
          Now for the practical part: how do you move from understanding code to confidently writing it yourself? Here are proven strategies to bridge this gap:<\/p>\n
          1. Implement Active Reading Techniques<\/h3>\n
          Don't just passively read code. Engage with it actively:<\/p>\n
            \n
          • Predict before you read<\/strong>: Before looking at a function's implementation, try to predict how it might be coded based on its name and purpose.<\/li>\n
          • Explain in your own words<\/strong>: After reading a section of code, close the file and explain what it does aloud, as if teaching someone else.<\/li>\n
          • Question the implementation<\/strong>: Ask yourself \"Why did they choose this approach instead of alternatives?\"<\/li>\n
          • Identify patterns<\/strong>: Consciously note recurring patterns and give them names in your mind.<\/li>\n<\/ul>\n
            This active engagement transforms passive recognition into knowledge you can recall later.<\/p>\n
            2. Practice Incremental Writing<\/h3>\n
            Instead of trying to write complex functionality from scratch, build up incrementally:<\/p>\n
              \n
            1. Start with the simplest possible version that works<\/li>\n
            2. Add one feature or handle one edge case at a time<\/li>\n
            3. Test each increment before moving to the next<\/li>\n<\/ol>\n
              For example, if building a user authentication system, start with just the basic login function before adding password validation, security features, and error handling.<\/p>\n
              \/\/ Step 1: Basic function structure\nfunction loginUser(username, password) {\n    \/\/ Just return true for now\n    return true;\n}\n\n\/\/ Step 2: Add simple validation\nfunction loginUser(username, password) {\n    if (!username || !password) {\n        return false;\n    }\n    return true;\n}\n\n\/\/ Step 3: Add mock database check\nfunction loginUser(username, password) {\n    if (!username || !password) {\n        return false;\n    }\n    \n    \/\/ Mock database check\n    const validUser = { username: 'testuser', password: 'password123' };\n    \n    return username === validUser.username && password === validUser.password;\n}<\/code><\/pre>\n
              This incremental approach prevents the blank-page paralysis and builds your confidence as you see progress.<\/p>\n
              3. Use the \"Code Reconstruction\" Technique<\/h3>\n
              This powerful learning method involves:<\/p>\n
                \n
              1. Study a piece of code until you understand it thoroughly<\/li>\n
              2. Close the file and wait at least an hour (preferably a day)<\/li>\n
              3. Try to rewrite the same functionality from memory<\/li>\n
              4. Compare your version with the original and analyze differences<\/li>\n<\/ol>\n
                This technique bridges the gap between recognition and recall, forcing your brain to retrieve the patterns rather than just recognize them.<\/p>\n
                4. Build a Personal Code Snippet Library<\/h3>\n
                Create your own library of code patterns that you understand and can adapt:<\/p>\n
                  \n
                • Organize snippets by functionality (data transformation, API calls, validation, etc.)<\/li>\n
                • Add comments explaining how each snippet works and when to use it<\/li>\n
                • Include examples of how the snippet can be modified for different uses<\/li>\n<\/ul>\n
                  This library becomes a bridge between reading others' code and writing your own, giving you starting points that you can customize.<\/p>\n
                  5. Practice Deliberate Imitation<\/h3>\n
                  Artists learn by copying masters, and programmers can use the same approach:<\/p>\n
                    \n
                  1. Find well-written code that accomplishes something similar to your goal<\/li>\n
                  2. Study how it's structured and why certain decisions were made<\/li>\n
                  3. Write your own version, deliberately applying the patterns you observed<\/li>\n
                  4. Gradually modify and expand on these patterns to make them your own<\/li>\n<\/ol>\n
                    This isn't plagiarism when done as a learning exercise \u2014 it's how expertise has been developed for centuries in creative fields.<\/p>\n
                    6. Implement the \"Read-Cover-Recall-Check\" Method<\/h3>\n
                    This technique comes from effective study methods:<\/p>\n
                      \n
                    1. Read<\/strong>: Study a code example thoroughly<\/li>\n
                    2. Cover<\/strong>: Hide the code<\/li>\n
                    3. Recall<\/strong>: Write as much as you can remember<\/li>\n
                    4. Check<\/strong>: Compare your version with the original<\/li>\n<\/ol>\n
                      This approach strengthens the neural pathways needed for recall, making it easier to write similar code in the future.<\/p>\n
                      The Power of Breaking Down Problems<\/h2>\n
                      One of the biggest challenges in writing code from scratch is the overwhelming complexity of the whole problem. Expert developers don't tackle entire problems at once \u2014 they break them down into manageable components.<\/p>\n
                      The Decomposition Technique<\/h3>\n
                      When faced with a complex coding task:<\/p>\n
                        \n
                      1. Identify the major components or steps required<\/li>\n
                      2. Break each component into smaller, more manageable sub-problems<\/li>\n
                      3. Continue breaking down until each piece feels approachable<\/li>\n
                      4. Implement each small piece independently<\/li>\n
                      5. Integrate the pieces into a complete solution<\/li>\n<\/ol>\n
                        For example, if building a contact form with validation and submission:<\/p>\n
                          \n
                        • Component 1: HTML form structure\n
                            \n
                          • Sub-task: Create input fields<\/li>\n
                          • Sub-task: Style the form<\/li>\n<\/ul>\n<\/li>\n
                          • Component 2: Form validation\n
                              \n
                            • Sub-task: Validate email format<\/li>\n
                            • Sub-task: Check required fields<\/li>\n
                            • Sub-task: Display error messages<\/li>\n<\/ul>\n<\/li>\n
                            • Component 3: Form submission\n
                                \n
                              • Sub-task: Prevent default submit behavior<\/li>\n
                              • Sub-task: Collect form data<\/li>\n
                              • Sub-task: Send data to server<\/li>\n
                              • Sub-task: Handle response<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                                By tackling each sub-task individually, the formerly overwhelming project becomes a series of manageable challenges.<\/p>\n
                                The Pseudocode Bridge<\/h3>\n
                                Pseudocode serves as a bridge between your understanding of a problem and the actual code implementation. Before writing real code:<\/p>\n
                                  \n
                                1. Write out the logic in plain English or informal pseudocode<\/li>\n
                                2. Review and refine your approach<\/li>\n
                                3. Gradually translate each line of pseudocode into actual code<\/li>\n<\/ol>\n
                                  For example:<\/p>\n
                                  \/\/ Pseudocode\n\/\/ 1. Get all users from database\n\/\/ 2. Filter out inactive users\n\/\/ 3. Sort remaining users by last login date\n\/\/ 4. Return the first 10 users\n\n\/\/ Actual implementation\nasync function getRecentActiveUsers() {\n    \/\/ 1. Get all users from database\n    const allUsers = await database.getUsers();\n    \n    \/\/ 2. Filter out inactive users\n    const activeUsers = allUsers.filter(user => user.isActive);\n    \n    \/\/ 3. Sort remaining users by last login date\n    const sortedUsers = activeUsers.sort((a, b) => \n        new Date(b.lastLogin) - new Date(a.lastLogin)\n    );\n    \n    \/\/ 4. Return the first 10 users\n    return sortedUsers.slice(0, 10);\n}<\/code><\/pre>\n
                                  This approach makes the transition from understanding to implementation more gradual and manageable.<\/p>\n
                                  Overcoming Perfectionism and Analysis Paralysis<\/h2>\n
                                  Many developers struggle to write code from scratch because they aim for perfection on the first try. This perfectionism leads to analysis paralysis \u2014 the inability to start because you can't immediately see the perfect solution.<\/p>\n
                                  Embrace the Iterative Process<\/h3>\n
                                  Professional developers rarely write perfect code on the first attempt. Instead, they:<\/p>\n
                                    \n
                                  1. Write a \"good enough\" first version that works<\/li>\n
                                  2. Refactor to improve structure and readability<\/li>\n
                                  3. Optimize for performance if necessary<\/li>\n
                                  4. Add tests to ensure reliability<\/li>\n<\/ol>\n
                                    Give yourself permission to follow this same process. Your first attempt doesn't need to be perfect \u2014 it just needs to work well enough to build upon.<\/p>\n
                                    The 15-Minute Rule<\/h3>\n
                                    When stuck on a problem, follow the 15-minute rule:<\/p>\n
                                      \n
                                    1. Try to solve the problem on your own for 15 minutes<\/li>\n
                                    2. If still stuck, look for hints or examples (not complete solutions)<\/li>\n
                                    3. Try again with this new information for another 15 minutes<\/li>\n
                                    4. If still stuck, look at a solution, but then close it and implement your own version<\/li>\n<\/ol>\n
                                      This structured approach prevents both giving up too quickly and wasting hours when you need guidance.<\/p>\n
                                      Learning to Think Like a Programmer<\/h2>\n
                                      Beyond specific techniques, developing a \"programmer's mindset\" is crucial for bridging the understanding-creation gap.<\/p>\n
                                      Cultivate Algorithmic Thinking<\/h3>\n
                                      Practice describing processes as step-by-step algorithms in your daily life. For example, think about the algorithm for making a sandwich or finding the fastest route to work. This trains your brain to break problems into sequential steps.<\/p>\n
                                      Develop Pattern Recognition<\/h3>\n
                                      Actively look for patterns in code you read and problems you solve. Creating a \"pattern vocabulary\" helps you recognize when similar solutions can be applied to new problems.<\/p>\n
                                      Common patterns to recognize include:<\/p>\n
                                        \n
                                      • Iteration patterns (map, filter, reduce)<\/li>\n
                                      • Recursion patterns<\/li>\n
                                      • State management patterns<\/li>\n
                                      • Data transformation patterns<\/li>\n
                                      • Error handling patterns<\/li>\n<\/ul>\n
                                        Build Mental Models<\/h3>\n
                                        Develop clear mental models of how programming concepts work. For example, don't just memorize how to use array methods \u2014 understand how they work internally.<\/p>\n
                                        Strong mental models allow you to reason about code even when you don't remember the exact syntax or implementation details.<\/p>\n
                                        From Understanding to Creating: A Progressive Path<\/h2>\n
                                        Let's put everything together into a progressive learning path that takes you from understanding code to confidently creating it:<\/p>\n
                                        Stage 1: Active Comprehension (1-2 weeks)<\/h3>\n
                                          \n
                                        • Find high-quality code examples in your target language\/framework<\/li>\n
                                        • Practice active reading techniques with these examples<\/li>\n
                                        • Write summaries explaining how the code works and why certain decisions were made<\/li>\n
                                        • Create diagrams or flowcharts to visualize the code's operation<\/li>\n<\/ul>\n
                                          Stage 2: Guided Modification (2-3 weeks)<\/h3>\n
                                            \n
                                          • Take working code examples and modify them to add new features<\/li>\n
                                          • Fix intentionally broken code<\/li>\n
                                          • Rewrite existing functionality using different approaches<\/li>\n
                                          • Practice the \"code reconstruction\" technique<\/li>\n<\/ul>\n
                                            Stage 3: Scaffolded Creation (3-4 weeks)<\/h3>\n
                                              \n
                                            • Use pseudocode to plan solutions before coding<\/li>\n
                                            • Build solutions incrementally, testing each step<\/li>\n
                                            • Use your snippet library as a starting point<\/li>\n
                                            • Implement solutions with the help of documentation and references<\/li>\n<\/ul>\n
                                              Stage 4: Independent Creation (Ongoing)<\/h3>\n
                                                \n
                                              • Set progressively more challenging projects for yourself<\/li>\n
                                              • Build complete applications from scratch<\/li>\n
                                              • Contribute to open source projects<\/li>\n
                                              • Teach others to solidify your understanding<\/li>\n<\/ul>\n
                                                This gradual progression builds the neural pathways needed to move from understanding to creation, without the frustration of trying to leap directly from reading code to writing complex applications from scratch.<\/p>\n
                                                Common Obstacles and How to Overcome Them<\/h2>\n
                                                As you work to bridge the gap between understanding and creating code, you'll likely encounter some common obstacles:<\/p>\n
                                                Syntax Frustration<\/h3>\n
                                                Problem:<\/strong> You understand the logic but get stuck on syntax details.<\/p>\n
                                                Solution:<\/strong> Create syntax cheat sheets for your most-used language features. Use an IDE with good autocomplete features. Remember that even experienced developers regularly look up syntax \u2014 it's not a sign of weakness.<\/p>\n
                                                The Blank Editor Problem<\/h3>\n
                                                Problem:<\/strong> You freeze when facing an empty file, unsure where to start.<\/p>\n
                                                Solution:<\/strong> Start by writing comments outlining what you want to do. Create a standard template for projects or files that you can use as a starting point. Begin with the part you're most confident about, even if it's not the logical first step.<\/p>\n
                                                Comparing Yourself to Others<\/h3>\n
                                                Problem:<\/strong> You get discouraged seeing others write code quickly and confidently.<\/p>\n
                                                Solution:<\/strong> Remember that you're seeing their finished performance, not their learning process. Most developers struggle when learning new concepts. Focus on your progress compared to your past self, not compared to others.<\/p>\n
                                                Tutorial Dependency<\/h3>\n
                                                Problem:<\/strong> You can follow tutorials but struggle to create similar projects independently.<\/p>\n
                                                Solution:<\/strong> After completing a tutorial, immediately build a similar project with different requirements. Start with small modifications to the tutorial project, then gradually create more independent work.<\/p>\n
                                                The Importance of Deliberate Practice<\/h2>\n
                                                Throughout this article, I've mentioned \"deliberate practice\" several times. This concept, popularized by psychologist K. Anders Ericsson, is crucial for moving from understanding to mastery.<\/p>\n
                                                Deliberate practice isn't just writing more code \u2014 it's practicing with specific intent to improve. Effective deliberate practice in programming includes:<\/p>\n
                                                  \n
                                                • Focus on specific skills<\/strong>: Instead of building a complete app, spend time mastering particular techniques (e.g., practice writing recursive functions or implementing specific design patterns)<\/li>\n
                                                • Immediate feedback<\/strong>: Test your code frequently and analyze what works and what doesn't<\/li>\n
                                                • Working at the edge of your ability<\/strong>: Choose challenges that push you just beyond your current comfort zone<\/li>\n
                                                • Reflection<\/strong>: Regularly review your code and approach to identify patterns and areas for improvement<\/li>\n<\/ul>\n
                                                  This type of focused practice accelerates the development of the neural connections needed for effective code creation.<\/p>\n
                                                  Conclusion: Understanding and Creating Are Different Skills<\/h2>\n
                                                  The gap between understanding code and being able to write it from scratch is natural and affects developers at all levels. It's not a reflection of your intelligence or potential as a programmer \u2014 it's simply a result of how our brains process and retrieve information.<\/p>\n
                                                  By recognizing that comprehension and creation are different cognitive skills requiring different types of practice, you can take a more structured approach to developing your coding abilities. The strategies outlined in this article provide a path from passive understanding to active creation:<\/p>\n
                                                    \n
                                                  1. Practice active reading to deepen comprehension<\/li>\n
                                                  2. Use techniques like code reconstruction to bridge recognition and recall<\/li>\n
                                                  3. Break down complex problems into manageable components<\/li>\n
                                                  4. Build incrementally rather than expecting perfection from the start<\/li>\n
                                                  5. Create a personal library of patterns and snippets<\/li>\n
                                                  6. Engage in deliberate practice focused on specific skills<\/li>\n<\/ol>\n
                                                    Remember that even experienced developers rarely write complex code from scratch without references, planning, or iterations. The goal isn't to memorize every syntax detail or algorithm but to develop the problem-solving mindset and pattern recognition that allows you to approach new challenges confidently.<\/p>\n
                                                    With consistent practice and patience, you'll gradually close the gap between what you can understand and what you can create, building both your skills and your confidence as a developer.<\/p>\n
                                                    What strategies have helped you bridge the gap between understanding and creating code? Share your experiences in the comments below!<\/p>\n","protected":false},"excerpt":{"rendered":"
                                                    The Coding Comprehension Paradox: Understanding vs. Creating Have you ever found yourself nodding along while reading someone else’s code, thinking…<\/p>\n","protected":false},"author":1,"featured_media":7298,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[23],"tags":[],"class_list":["post-7295","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-problem-solving"],"_links":{"self":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/7295"}],"collection":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/comments?post=7295"}],"version-history":[{"count":4,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/7295\/revisions"}],"predecessor-version":[{"id":7306,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/posts\/7295\/revisions\/7306"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media\/7298"}],"wp:attachment":[{"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/media?parent=7295"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/categories?post=7295"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/algocademy.com\/blog\/wp-json\/wp\/v2\/tags?post=7295"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}