<?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 Jean claude adjanohoun on Medium]]></title>
        <description><![CDATA[Stories by Jean claude adjanohoun on Medium]]></description>
        <link>https://medium.com/@johnadjanohoun?source=rss-d7e07444c841------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*NShwIHS1SFxJzwHs1bfZzg@2x.jpeg</url>
            <title>Stories by Jean claude adjanohoun on Medium</title>
            <link>https://medium.com/@johnadjanohoun?source=rss-d7e07444c841------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 13:29:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@johnadjanohoun/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[Beyond Vibe Coding: How to Use LLMs Efficiently for Production Software.]]></title>
            <link>https://medium.com/@johnadjanohoun/beyond-vibe-coding-how-to-use-llms-efficiently-for-production-software-b3d73f046e08?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/b3d73f046e08</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 10:50:04 GMT</pubDate>
            <atom:updated>2026-10-23T10:50:04.499Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nwvKAkFHc3v55Y3gmPGkVg.png" /></figure><p>I’m a <strong>Software Engineer and Student Pilot</strong> with a strong passion for <strong>Data Structures and Algorithms (DSA), System Design, and Artificial Intelligence</strong>.</p><p>I enjoy solving challenging programming problems, understanding how algorithms work, analyzing time and space complexity, and exploring how large-scale software systems are designed and built.</p><p>As a Student Pilot, aviation has also strengthened my appreciation for discipline, checklists, systematic problem-solving, and making informed decisions — principles I apply to software engineering.</p><p>I love using Large Language Models (LLMs) as part of my development workflow. However, I’ve learned that getting the most out of these tools requires more than simply asking them to generate code.</p><p>There is a significant difference between <strong>vibe coding</strong> and using AI effectively to engineer reliable, maintainable, production-quality software.</p><p>Vibe coding often focuses on describing what you want, accepting generated code, and hoping everything works.</p><p>Professional software engineering requires something deeper: understanding the problem, designing the solution, evaluating tradeoffs, implementing carefully, testing thoroughly, and taking responsibility for the result.</p><p>LLMs can accelerate this entire process when used correctly.</p><p>The goal isn’t to replace engineering knowledge with AI. It’s to combine engineering knowledge with AI to become a more efficient and productive developer.</p><p>In this article, I’ll explain how I approach LLM-assisted software development and share practical techniques for using these tools effectively.</p><h3>The Five Biggest Challenges of Coding with LLMs</h3><p>Many developers become frustrated with AI-generated code because they encounter recurring problems:</p><ol><li><strong>Constant refactoring:</strong> The generated code is poorly structured, incorrect, or requires repeated changes.</li><li><strong>Lack of context:</strong> The model doesn’t understand the existing codebase, architecture, libraries, or APIs.</li><li><strong>Poor instruction following:</strong> The model ignores requirements, misunderstands intent, or introduces unnecessary changes.</li><li><strong>Doom loops:</strong> The model repeatedly attempts to fix a bug without identifying its actual cause.</li><li><strong>Complexity limitations:</strong> The model struggles with large codebases, complicated business logic, and systems involving multiple components.</li></ol><p>These challenges don’t necessarily mean LLMs are ineffective.</p><p>Often, they indicate that we’re using the technology without a structured engineering process.</p><p>I prefer thinking of an LLM as a <strong>powerful engineering assistant rather than a magic wand</strong>.</p><p>A magic wand approach is simple: describe a feature and expect a perfect implementation.</p><p>A disciplined engineering approach is different: analyze the problem, establish context, design a solution, review the plan, and then generate code.</p><p>Let’s explore how to overcome each challenge.</p><h3>1. Constant Refactoring: Have the Conversation Before Writing Code</h3><p>One of the most common mistakes when using LLMs is requesting an implementation before fully understanding the problem.</p><p>For example, imagine asking an LLM:</p><p>“Build an authentication system for my application.”</p><p>It might immediately produce hundreds of lines of code.</p><p>But several important questions remain unanswered.</p><p>What authentication method should be used? How should sessions be managed? What security requirements exist? How will the solution integrate with the existing architecture? What should happen when authentication fails?</p><p>Without these details, the generated solution may technically run while still being unsuitable for the project.</p><p>This is why I believe the most important step happens before writing code.</p><p><strong>The conversation comes first.</strong></p><p>My interest in DSA and System Design reinforces this principle.</p><p>When solving an algorithmic problem, I don’t want to jump straight into implementation without understanding the constraints, possible approaches, and complexity tradeoffs.</p><p>The same philosophy applies to production software.</p><h3>My Conversation-First Workflow</h3><p><strong>Step 1: Understand the problem.</strong></p><p>Explain the requirements, expected behavior, constraints, existing architecture, and business objectives to the LLM.</p><p><strong>Step 2: Explore possible solutions.</strong></p><p>Ask the model to propose multiple approaches and explain their advantages and disadvantages.</p><p>For example:</p><p>“Analyze this problem and propose an implementation strategy. Consider alternative approaches, tradeoffs, edge cases, and time and space complexity. Do not write code yet.”</p><p><strong>Step 3: Review the design.</strong></p><p>Evaluate the proposed solution yourself.</p><p>Does it make sense? Is it scalable? Does it introduce unnecessary complexity? Are there simpler alternatives?</p><p><strong>Step 4: Create a specification.</strong></p><p>Once the approach is clear, ask the LLM to write a structured implementation plan.</p><p>The specification should describe the expected behavior, architecture, dependencies, data structures, interfaces, and testing requirements.</p><p><strong>Step 5: Implement the solution.</strong></p><p>Only after reviewing and approving the plan should the model begin generating code.</p><p>This approach is closely related to <strong>Spec-Driven Development (SDD)</strong>.</p><p>Instead of allowing the model to make architectural decisions independently, the developer establishes the direction and uses AI to accelerate implementation.</p><h3>Why This Matters</h3><p>As developers, we are responsible for the software we build.</p><p>An LLM may generate a function in seconds, but that doesn’t mean the function is correct, efficient, secure, or maintainable.</p><p>For example, a generated algorithm might pass the sample test cases while having an unnecessary O(n²) time complexity.</p><p>A developer who understands DSA can recognize the problem, determine whether an O(n) or O(n log n) solution is possible, and guide the model toward a better implementation.</p><p>Similarly, knowledge of System Design helps us determine whether a solution will function reliably beyond a local development environment.</p><p>I don’t believe we should accept code simply because an AI generated it.</p><p>We should understand the logic, verify the assumptions, test the edge cases, and evaluate the engineering tradeoffs.</p><p><strong>You can delegate code generation, but you cannot delegate engineering accountability.</strong></p><p>This is where LLMs become extremely useful.</p><p>They reduce the time spent writing repetitive code and allow us to dedicate more attention to architectural decisions, problem-solving, and quality.</p><h3>2. Lack of Context: Teach the LLM Your Codebase</h3><p>Imagine joining a software engineering team and being asked to implement a feature on your first day.</p><p>You might know JavaScript, Python, databases, APIs, and distributed systems, but you still wouldn’t understand the team’s internal architecture.</p><p>You would need to learn how the application works, how services communicate, what coding standards are followed, and where the relevant functionality exists.</p><p>LLMs face a similar challenge.</p><p>Even a capable model cannot reliably modify a system it doesn’t understand.</p><p><strong>Before asking an LLM to implement a feature, help it understand the environment.</strong></p><h3>Let the LLM Explore the Codebase</h3><p>Modern AI coding tools can read project files, inspect functions, follow imports, and analyze relationships between components.</p><p>Instead of immediately requesting code changes, I prefer starting with an exploration prompt.</p><p>For example:</p><p>“Analyze this repository and explain its architecture. Identify the main components, entry points, dependencies, API endpoints, data flow, and coding patterns. Do not modify any files.”</p><p>This gives the model an opportunity to build a clearer picture of the application.</p><p>For a backend service, I might ask it to trace a request from the API endpoint through the business logic, database operations, and response handling.</p><p>For a frontend application, I might ask it to examine the component hierarchy, state management, routing, and API integration.</p><p>For a distributed application, I would want to understand the boundaries between services and how data moves through the system.</p><h3>Generate Documentation</h3><p>Another useful practice is asking the LLM to create documentation after exploring the codebase.</p><p>The documentation can include architectural overviews, important modules, dependencies, coding conventions, API contracts, and diagrams.</p><p>Mermaid diagrams can be especially useful for visualizing interactions between components.</p><p>For example, imagine a system with the following data flow:</p><p>Client Application → API Gateway → Backend Service → Business Logic → Database → Response</p><p>An LLM can help explain how each component interacts with the others, provided it has access to the relevant implementation.</p><p>That documentation can be stored in a docs/ directory and reused during future development sessions.</p><p>Of course, AI-generated documentation should be reviewed because a model can misunderstand relationships or make incorrect assumptions.</p><h3>Establish Coding Standards</h3><p>Context isn’t just about understanding what the code does.</p><p>It’s also about understanding how the team expects code to be written.</p><p>A project may have specific conventions for naming, testing, error handling, logging, API design, and dependency management.</p><p>Coding agents can use instruction files such as AGENTS.md or CLAUDE.md to receive reusable project guidance.</p><p>These files can describe the preferred coding style, architecture, testing expectations, and constraints.</p><p>For example, useful instructions might include:</p><p>“Follow the existing project architecture. Avoid unnecessary dependencies. Do not duplicate business logic. Handle errors explicitly. Add tests for new functionality. Explain significant architectural changes before implementing them.”</p><p>With clear context and standards, the model is less likely to introduce inconsistent or unnecessary code.</p><p><strong>The better the context, the better the implementation.</strong></p><h3>3. Poor Instruction Following: Choose the Right Model and Manage Context</h3><p>Not all LLMs perform equally well on software engineering tasks.</p><p>Some are excellent at explaining concepts, while others are better at complex reasoning, understanding large codebases, or modifying existing implementations.</p><p>When choosing an AI model for development, I pay attention to its ability to follow instructions, reason through problems, understand context, and produce maintainable code.</p><h3>Instruction Following Matters</h3><p>Suppose you tell an LLM:</p><p>“Refactor this function without changing its behavior, return type, or public interface.”</p><p>A poorly guided model might introduce new dependencies, rename functions, modify unrelated files, or change behavior that wasn’t part of the request.</p><p>Even if the resulting code appears cleaner, it hasn’t followed the instructions correctly.</p><p>This is particularly important when working in an existing codebase.</p><p>A small change can have consequences for downstream systems, existing tests, and other developers.</p><p>I prefer giving explicit requirements and constraints.</p><p>For example:</p><p>“Review this function and suggest improvements to readability and performance. Preserve the function signature and expected behavior. Do not introduce new dependencies. Explain the tradeoffs and wait for approval before making changes.”</p><p>The objective is to reduce ambiguity.</p><h3>Manage the Context Window</h3><p>Another important concept is the <strong>context window</strong>.</p><p>The context window represents how much information an LLM can consider during a particular interaction.</p><p>When working with a coding agent, the conversation can grow quickly.</p><p>The model may accumulate source code, terminal output, test failures, logs, implementation plans, and previous discussions.</p><p>Over time, the conversation can become crowded with outdated information or conflicting instructions.</p><p>This can negatively affect the model’s performance.</p><p>A practical solution is to organize work into manageable sessions.</p><p>For example, after completing a feature, I can ask the LLM to prepare a handoff summary describing the original objective, architectural decisions, files changed, tests completed, outstanding problems, and next steps.</p><p>That summary can then serve as context for a new session.</p><p>Some coding agents also support context-compaction features that summarize earlier conversation history.</p><p>These techniques help preserve the most important information while reducing unnecessary context.</p><p>The key principle is simple:</p><p><strong>Give the model enough context to make good decisions, but avoid overwhelming it with irrelevant information.</strong></p><h3>Use LLMs to Strengthen Understanding</h3><p>Because I’m passionate about DSA, I also enjoy using LLMs as learning and reasoning partners.</p><p>For example, after solving an algorithmic problem, I can ask the model to review the implementation, analyze its time and space complexity, identify edge cases, and propose alternative approaches.</p><p>I can then compare those approaches with my own reasoning.</p><p>This is different from asking AI to solve every problem without thinking.</p><p>The objective is to deepen understanding rather than bypass the learning process.</p><p>A developer who understands algorithms, system architecture, and software fundamentals will generally be better equipped to evaluate AI-generated solutions.</p><h3>4. Doom Loops: Investigate the Bug Before Trying to Fix It</h3><p>A doom loop happens when an LLM repeatedly attempts to fix a problem without understanding its root cause.</p><p>Imagine a failing test.</p><p>You paste the error message into the model and ask it to fix the issue.</p><p>It changes the implementation, but the test still fails.</p><p>You ask again.</p><p>The model makes another change, introducing a different problem.</p><p>After several attempts, the code becomes increasingly complicated while the original issue remains unresolved.</p><p>This is frustrating, but it can often be avoided.</p><p><strong>Debugging should begin with investigation, not random code changes.</strong></p><h3>My Debugging Approach</h3><p>When encountering a bug, I prefer asking the LLM to investigate before modifying the implementation.</p><p>For example:</p><p>“Investigate this bug. Analyze the stack trace, relevant code paths, inputs, and expected behavior. Identify possible root causes and explain your findings. Do not modify any code yet.”</p><p>This separates diagnosis from implementation.</p><p>The model can inspect relevant functions, trace execution paths, compare expected and actual behavior, and identify suspicious assumptions.</p><p>Once it presents its findings, I can evaluate the explanation.</p><p>Does the proposed root cause make sense? Is there evidence supporting it? Can the problem be reproduced reliably?</p><p>If necessary, I can ask the model to simulate specific inputs or trace variables step by step.</p><h3>Think Like an Algorithm Engineer</h3><p>DSA provides a useful mental framework for debugging.</p><p>When analyzing an algorithm, we frequently examine its behavior under different inputs.</p><p>We test boundary conditions, empty collections, duplicate values, invalid inputs, and large datasets.</p><p>The same systematic thinking applies to application debugging.</p><p>For instance, a function might behave correctly with a small array but fail when the input becomes large because of poor complexity or unexpected memory consumption.</p><p>Another function might fail only when an object is null, an API response is delayed, or a database query returns no results.</p><p>Instead of guessing, we investigate the conditions that trigger the failure.</p><p>Only after identifying the likely root cause should we design a solution.</p><p>I might then ask:</p><p>“Based on the investigation, propose the safest fix. Explain how it resolves the root cause, what other behavior it could affect, and which tests should be added. Do not implement it until I approve.”</p><p>Once the plan is satisfactory, implementation can begin.</p><p>Afterward, the fix should be verified through appropriate testing.</p><p>An LLM is not an automatic guarantee of correctness, but it can be an excellent debugging assistant when guided through a structured process.</p><h3>5. Complexity Limits: Break Large Problems Into Smaller Tasks</h3><p>One of the most important lessons in software engineering is that complex systems become more manageable when we break them into smaller components.</p><p>This principle is fundamental to both DSA and System Design.</p><p>When solving a difficult algorithmic problem, we often identify smaller subproblems, useful data structures, and reusable patterns.</p><p>When designing a large-scale application, we separate responsibilities across modules, services, interfaces, and data layers.</p><p>The same approach works with LLMs.</p><p>Imagine asking an AI agent:</p><p>“Build a complete e-commerce platform with authentication, payments, inventory management, order processing, notifications, and analytics.”</p><p>The request contains many independent problems.</p><p>An LLM may generate a convincing demonstration, but creating a reliable production system requires careful attention to security, consistency, scalability, failure handling, and integration.</p><p>Trying to implement everything in one request increases the likelihood of errors.</p><p>The solution is <strong>decomposition</strong>.</p><h3>Apply Spec-Driven Development</h3><p>Start by defining the overall objective and architectural requirements.</p><p>Next, divide the project into clearly defined components.</p><p>For an e-commerce system, that might involve user authentication, product catalog, inventory, shopping cart, payment processing, order management, and notifications.</p><p>Each component can then be broken into smaller implementation tasks.</p><p>For example, order management might require defining database models, creating API endpoints, implementing business rules, handling order status transitions, integrating with payments, and writing tests.</p><p>Instead of asking the model to implement the entire platform, focus on one bounded task at a time.</p><p>A useful workflow looks like this:</p><ol><li><strong>Understand:</strong> Clarify requirements, constraints, and expected behavior.</li><li><strong>Design:</strong> Compare approaches and identify tradeoffs.</li><li><strong>Specify:</strong> Document the chosen implementation plan.</li><li><strong>Decompose:</strong> Divide the plan into small, testable tasks.</li><li><strong>Implement:</strong> Generate and review code for one task at a time.</li><li><strong>Validate:</strong> Run tests, inspect behavior, and verify correctness.</li><li><strong>Integrate:</strong> Confirm the component works with the rest of the system.</li></ol><p>This approach gives the model a narrower problem to solve and gives the developer more control over the implementation.</p><h3>DSA and System Design Still Matter</h3><p>I strongly believe that understanding computer science fundamentals remains essential in the age of AI.</p><p>DSA helps us reason about efficient algorithms, data structures, complexity, and correctness.</p><p>System Design helps us understand scalability, availability, reliability, fault tolerance, caching, databases, APIs, and distributed architecture.</p><p>LLMs can assist with both, but they don’t eliminate the need for engineering judgment.</p><p>For example, an AI might suggest a solution that works well for a few hundred records but performs poorly when processing millions.</p><p>A developer with a solid understanding of complexity analysis can recognize this risk.</p><p>Similarly, an LLM might propose a service architecture without adequately considering consistency, network failures, or database bottlenecks.</p><p>System Design knowledge helps us question those decisions.</p><p><strong>Knowing how to write code is valuable. Knowing why a particular solution is appropriate is even more valuable.</strong></p><p>And being able to use LLMs to accelerate that process is an increasingly useful engineering skill.</p><h3>My Philosophy: Engineer First, Generate Second</h3><p>I enjoy using LLMs because they make software development more interactive, efficient, and intellectually engaging.</p><p>They can help explore unfamiliar codebases, compare algorithms, explain difficult concepts, generate tests, document architecture, investigate bugs, and accelerate implementation.</p><p>But I don’t believe that writing code faster automatically means building better software.</p><p>The real value comes from combining AI capabilities with strong engineering fundamentals.</p><p>For me, that means continuing to strengthen my knowledge of DSA, System Design, programming languages, software architecture, and problem-solving.</p><p>It also means using LLMs deliberately rather than accepting every generated answer.</p><p>I want to understand the problem before implementing a solution.</p><p>I want to consider complexity before selecting an algorithm.</p><p>I want to evaluate architectural tradeoffs before introducing new components.</p><p>And I want to understand and test the code before treating it as production-ready.</p><p>LLMs can dramatically reduce the mechanical effort involved in software development, but developers must still own the technical decisions and their consequences.</p><h3>Final Thoughts</h3><p>We’re entering an exciting era of software engineering.</p><p>Developers now have access to AI tools that can assist with tasks that previously required substantial manual effort.</p><p>However, these tools are most valuable when paired with structured thinking, clear communication, and sound engineering principles.</p><p>My approach to using LLMs efficiently is straightforward:</p><p><strong>Understand the problem. Design the solution. Provide the right context. Break down complexity. Generate carefully. Test thoroughly.</strong></p><p>That is the difference between simply generating code and engineering software with AI.</p><p>As both a Software Engineer and Student Pilot, I value continuous learning, technical precision, discipline, and systematic decision-making.</p><p>Whether I’m studying algorithms, exploring system architecture, building software, or learning to fly, I believe the fundamentals matter.</p><p>The future isn’t just about who can generate code the fastest.</p><p><strong>It’s about who can combine engineering knowledge, critical thinking, and AI to build reliable, efficient, and scalable software.</strong></p><p>If this article helps you approach AI-assisted development more effectively, feel free to share it with other developers.</p><p>Let’s keep learning, building, and improving.</p><p><strong>Jean Claude Adjanohoun</strong></p><p><em>Software Engineer | Student Pilot | DSA &amp; System Design Enthusiast | AI &amp; LLM Enthusiast</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b3d73f046e08" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Before the Engine Starts, Before the Airplane Flies.]]></title>
            <link>https://medium.com/@johnadjanohoun/before-the-engine-starts-before-the-airplane-flies-94445094976d?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/94445094976d</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Wed, 26 Aug 2026 08:18:32 GMT</pubDate>
            <atom:updated>2026-08-26T08:18:32.189Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*irX1MZ6fiCcf0P71hJKb-A@2x.jpeg" /></figure><p>Flying starts long before the wheels leave the ground. A safe flight begins with preparation, discipline, and knowing your airplane.</p><p>Part 1 — Before Starting the Engine</p><p>Before starting the engine, I go through the cockpit carefully.</p><p>Prime the engine as required. Master switch on. Mixture full rich. Fuel selector on both. Throttle open slightly for the engine start. Flaps up as required.</p><p>Set the altimeter to the current setting and prepare the radios. COM 1 is ready for Ground and Tower, while COM 2 can be used for ATIS. For a normal VFR flight, the transponder is set to 1200 unless ATC assigns another code. Lights and pitot heat are set as required by the aircraft checklist and conditions.</p><p>Then comes one of the most important calls:</p><p>“CLEAR PROP!”</p><p>After the engine starts, check the engine indications, listen to ATIS, contact Ground, receive the taxi clearance, and taxi carefully toward the run-up area.</p><p>Part 2 — Run-Up and Before Takeoff</p><p>The run-up area is the final opportunity to make sure the airplane is ready to fly.</p><p>Position the airplane safely and hold the brakes. Go through the checklist again. Check the flight controls, instruments, fuel, mixture, trim, and other required items.</p><p>For the engine run-up, set the RPM specified by the aircraft checklist — commonly around 1,700 RPM in many training Cessnas.</p><p>Check one magneto, return to BOTH, check the other magneto, and return to BOTH. Watch the tachometer carefully. An RPM drop is expected, but it must remain within the limits specified by the aircraft’s POH.</p><p>Complete the remaining before-takeoff checks. When everything is ready, select the Tower frequency and request takeoff clearance.</p><p>Once cleared onto the runway, align the airplane, smoothly apply takeoff power, and verify that the engine instruments are showing normal indications.</p><p>As the airplane accelerates, rotate and establish the climb using the speeds and procedures specified for that airplane.</p><p>And remember the relationships that every pilot should keep in mind:</p><p>Power for altitude. Pitch for airspeed.</p><p>And when the workload increases:</p><p>Aviate. Navigate. Communicate.</p><p>Aviate — Fly the airplane first.</p><p>Navigate — Know where you are and where you’re going.</p><p>Communicate — Talk to ATC when appropriate.</p><p>Every flight is different, but the discipline stays the same.</p><p>Check. Verify. Communicate. Then fly.</p><p>Always follow the specific aircraft POH/checklist and your instructor’s procedures for exact settings, speeds, and limitations.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=94445094976d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You Belong at the Table — Know Your Worth.]]></title>
            <link>https://medium.com/@johnadjanohoun/you-belong-at-the-table-know-your-worth-6b04da35adc0?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/6b04da35adc0</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Sat, 21 Feb 2026 08:14:08 GMT</pubDate>
            <atom:updated>2026-02-21T08:14:08.689Z</atom:updated>
            <content:encoded><![CDATA[<p><strong>You Belong at the Table — Know Your Worth.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*YuBfu6Ya9REgcTcpGV6YWg@2x.jpeg" /></figure><p>One of the biggest lies we tell ourselves is that the people at the “big tables” — executives, founders, politicians — are somehow different from us.</p><p>Smarter. More deserving. More special.</p><p>They’re not.</p><p>When you actually sit in those rooms, you realize something simple: they’re just people.</p><p>Most of what we mistake for genius is exposure.</p><p>Most of what we mistake for superiority is confidence.</p><p>And most of what we mistake for belonging is someone who decided they had the right to be there.</p><p>Titles don’t remove fear. They just hide it better. Behind every position is a human being navigating doubt, pressure, and uncertainty — just like you.</p><p>The difference? They showed up anyway.</p><p>Many times, no one disqualified you. You disqualified yourself. You assumed you weren’t ready. You assumed someone else was better.</p><p>But readiness often comes after you take the seat.</p><p>Belonging isn’t granted — it’s claimed.</p><p>The moment you stop putting people on pedestals is the moment you realize you’re already standing on your own.</p><p>You belong in more rooms than you think.</p><p>Know your worth — and take the seat.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6b04da35adc0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The 50 Coding Interview Problems That Form My Complete DSA Blueprint]]></title>
            <link>https://medium.com/@johnadjanohoun/the-50-coding-interview-problems-that-form-my-complete-dsa-blueprint-ef796cd0d1b6?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef796cd0d1b6</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Sat, 14 Feb 2026 06:35:22 GMT</pubDate>
            <atom:updated>2026-02-14T06:35:22.202Z</atom:updated>
            <content:encoded><![CDATA[<p>You don’t need 500 problems.</p><p>You need the right 50 — deeply understood.</p><p>These 50 questions form a complete mental blueprint across arrays, sliding window, linked lists, trees, graphs, heaps, stacks, and dynamic programming.</p><p>If you understand the goal and thinking process behind each one, you can solve most variations confidently.</p><p>Let’s go.</p><h3>🟢 ARRAYS &amp; HASHING</h3><h3>1️⃣ Two Sum</h3><p>🎯 Goal: Find two numbers adding to target.<br> 🧠 Steps:</p><ol><li>Iterate once.</li><li>Compute complement.</li><li>Check hashmap.</li><li>Store current number.<br> ⏱ O(n) | O(n)</li></ol><h3>2️⃣ 3Sum</h3><p>🎯 Goal: Find unique triplets summing to zero.<br> 🧠 Steps:</p><ol><li>Sort array.</li><li>Fix one element.</li><li>Use two pointers.</li><li>Skip duplicates.<br> ⏱ O(n²) | O(1)</li></ol><h3>3️⃣ Remove Duplicates (Sorted Array)</h3><p>🎯 Goal: Remove duplicates in-place.<br> 🧠 Steps:</p><ol><li>Slow pointer tracks unique.</li><li>Fast pointer scans.</li><li>Overwrite duplicates.<br> ⏱ O(n) | O(1)</li></ol><h3>4️⃣ Contains Duplicate</h3><p>🎯 Goal: Detect repetition.<br> 🧠 Steps:</p><ol><li>Insert into set.</li><li>If already exists → true.<br> ⏱ O(n) | O(n)</li></ol><h3>5️⃣ Find the Duplicate Number</h3><p>🎯 Goal: Find repeated value without modifying array.<br> 🧠 Steps:</p><ol><li>Treat array as linked list.</li><li>Use slow/fast pointers.</li><li>Find cycle entrance.<br> ⏱ O(n) | O(1)</li></ol><h3>6️⃣ Maximum Product Subarray</h3><p>🎯 Goal: Max product of contiguous subarray.<br> 🧠 Steps:</p><ol><li>Track max &amp; min at each step.</li><li>Swap on negative.</li><li>Update global max.<br> ⏱ O(n) | O(1)</li></ol><h3>7️⃣ Merge Intervals</h3><p>🎯 Goal: Merge overlapping intervals.<br> 🧠 Steps:</p><ol><li>Sort by start.</li><li>Compare with last merged.</li><li>Merge if overlapping.<br> ⏱ O(n log n)</li></ol><h3>8️⃣ Longest Consecutive Sequence</h3><p>🎯 Goal: Longest consecutive numbers sequence.<br> 🧠 Steps:</p><ol><li>Store in set.</li><li>Start only at numbers where n-1 not present.</li><li>Count forward.<br> ⏱ O(n)</li></ol><h3>🟡 SLIDING WINDOW</h3><h3>9️⃣ Longest Substring Without Repeating</h3><p>🎯 Goal: Longest unique substring.<br> 🧠 Steps:</p><ol><li>Expand right pointer.</li><li>If duplicate → move left.</li><li>Track max length.<br> ⏱ O(n)</li></ol><h3>🔟 Minimum Window Substring</h3><p>🎯 Goal: Smallest substring containing all chars.<br> 🧠 Steps:</p><ol><li>Expand until valid.</li><li>Shrink while valid.</li><li>Track minimum.<br> ⏱ O(n)</li></ol><h3>1️⃣1️⃣ Find All Anagrams</h3><p>🎯 Goal: All anagram start indices.<br> 🧠 Steps:</p><ol><li>Fixed-size sliding window.</li><li>Frequency comparison.</li><li>Move window one step.<br> ⏱ O(n)</li></ol><h3>1️⃣2️⃣ Permutation in String</h3><p>🎯 Goal: Check if permutation exists.<br> 🧠 Steps:</p><ol><li>Same logic as anagram.</li><li>Return true when match found.<br> ⏱ O(n)</li></ol><h3>1️⃣3️⃣ Longest Palindromic Substring</h3><p>🎯 Goal: Find longest palindrome.<br> 🧠 Steps:</p><ol><li>Expand around each center.</li><li>Track max length.<br> ⏱ O(n²)</li></ol><h3>🔵 LINKED LISTS</h3><h3>1️⃣4️⃣ Reverse Linked List</h3><p>🎯 Reverse in-place.<br> 🧠 Use prev, curr, next pointers.<br> ⏱ O(n)</p><h3>1️⃣5️⃣ Linked List Cycle</h3><p>🎯 Detect cycle.<br> 🧠 Slow &amp; fast pointers.<br> ⏱ O(n)</p><h3>1️⃣6️⃣ Linked List Cycle II</h3><p>🎯 Find cycle start.<br> 🧠 Reset one pointer after meeting.<br> ⏱ O(n)</p><h3>1️⃣7️⃣ Merge Two Sorted Lists</h3><p>🎯 Merge two sorted linked lists.<br> 🧠 Compare nodes and attach smaller.<br> ⏱ O(n)</p><h3>1️⃣8️⃣ Reorder List</h3><p>🎯 Reorder L0→Ln→L1→Ln-1…<br> 🧠 Find middle, reverse second half, merge alternately.<br> ⏱ O(n)</p><h3>🌳 TREES</h3><h3>1️⃣9️⃣ Binary Tree Level Order</h3><p>🎯 BFS traversal.<br> 🧠 Use queue.<br> ⏱ O(n)</p><h3>2️⃣0️⃣ Diameter of Binary Tree</h3><p>🎯 Longest path.<br> 🧠 Post-order DFS, compute height.<br> ⏱ O(n)</p><h3>2️⃣1️⃣ Max Path Sum</h3><p>🎯 Max sum anywhere.<br> 🧠 Ignore negative branches.<br> ⏱ O(n)</p><h3>2️⃣2️⃣ Validate BST</h3><p>🎯 Check BST validity.<br> 🧠 Maintain min/max bounds.<br> ⏱ O(n)</p><h3>2️⃣3️⃣ Lowest Common Ancestor</h3><p>🎯 Find shared ancestor.<br> 🧠 Recurse left &amp; right.<br> ⏱ O(n)</p><h3>2️⃣4️⃣ Invert Binary Tree</h3><p>🎯 Swap children recursively.<br> ⏱ O(n)</p><h3>2️⃣5️⃣ Serialize &amp; Deserialize</h3><p>🎯 Convert tree ↔ string.<br> 🧠 BFS/DFS with null markers.<br> ⏱ O(n)</p><h3>🌐 GRAPHS</h3><h3>2️⃣6️⃣ Number of Islands</h3><p>🎯 Count connected components.<br> 🧠 DFS/BFS mark visited.<br> ⏱ O(mn)</p><h3>2️⃣7️⃣ Rotting Oranges</h3><p>🎯 Time until all rot.<br> 🧠 Multi-source BFS.<br> ⏱ O(mn)</p><h3>2️⃣8️⃣ Course Schedule</h3><p>🎯 Detect cycle.<br> 🧠 Topological sort.<br> ⏱ O(V+E)</p><h3>2️⃣9️⃣ Course Schedule II</h3><p>🎯 Return ordering.<br> 🧠 Kahn’s BFS topo sort.<br> ⏱ O(V+E)</p><h3>3️⃣0️⃣ Clone Graph</h3><p>🎯 Deep copy graph.<br> 🧠 DFS/BFS + visited map.<br> ⏱ O(V+E)</p><h3>3️⃣1️⃣ Shortest Path in Binary Matrix</h3><p>🎯 Shortest path in grid.<br> 🧠 BFS guarantees shortest path.<br> ⏱ O(n²)</p><h3>🔴 BACKTRACKING</h3><h3>3️⃣2️⃣ Word Search</h3><p>🎯 Word exists in grid.<br> 🧠 DFS with backtracking.</p><h3>3️⃣3️⃣ Word Search II</h3><p>🎯 Find multiple words.<br> 🧠 Trie + DFS pruning.</p><h3>3️⃣4️⃣ Sudoku Solver</h3><p>🎯 Solve board.<br> 🧠 Try numbers, validate, backtrack.</p><h3>🟣 HEAPS &amp; STACKS</h3><h3>3️⃣5️⃣ Top K Frequent Elements</h3><p>🎯 Return k frequent.<br> 🧠 Frequency map + heap.<br> ⏱ O(n log k)</p><h3>3️⃣6️⃣ Kth Largest Element</h3><p>🎯 Find kth largest.<br> 🧠 Min-heap or Quickselect.</p><h3>3️⃣7️⃣ Median from Data Stream</h3><p>🎯 Maintain dynamic median.<br> 🧠 Two heaps (max + min).</p><h3>3️⃣8️⃣ 132 Pattern</h3><p>🎯 Detect pattern.<br> 🧠 Traverse from right + monotonic stack.</p><h3>🟠 DYNAMIC PROGRAMMING</h3><h3>3️⃣9️⃣ House Robber</h3><p>🎯 Max non-adjacent sum.<br> 🧠 dp[i] = max(skip, rob).<br> ⏱ O(n)</p><h3>4️⃣0️⃣ Maximum Subarray</h3><p>🎯 Largest sum contiguous.<br> 🧠 Kadane’s algorithm.<br> ⏱ O(n)</p><h3>4️⃣1️⃣ Best Time to Buy/Sell Stock</h3><p>🎯 Max profit.<br> 🧠 Track min price so far.<br> ⏱ O(n)</p><h3>4️⃣2️⃣ Climbing Stairs</h3><p>🎯 Ways to reach top.<br> 🧠 Fibonacci DP.<br> ⏱ O(n)</p><h3>4️⃣3️⃣ Coin Change</h3><p>🎯 Min coins to make amount.<br> 🧠 Bottom-up DP.<br> ⏱ O(n × amount)</p><h3>🟤 CLASSIC PATTERNS</h3><h3>4️⃣4️⃣ Binary Search</h3><p>🎯 Find target in sorted array.<br> 🧠 Divide search space.<br> ⏱ O(log n)</p><h3>4️⃣5️⃣ Spiral Matrix</h3><p>🎯 Traverse in spiral order.<br> 🧠 Maintain boundaries.</p><h3>4️⃣6️⃣ Rotate Image</h3><p>🎯 Rotate matrix 90°.<br> 🧠 Transpose + reverse rows.</p><h3>4️⃣7️⃣ Valid Anagram</h3><p>🎯 Check if strings are anagrams.<br> 🧠 Frequency counting.</p><h3>4️⃣8️⃣ Valid Palindrome</h3><p>🎯 Check if string palindrome.<br> 🧠 Two pointers inward.</p><h3>4️⃣9️⃣ Trie (Prefix Tree)</h3><p>🎯 Efficient prefix search.<br> 🧠 Build tree of characters.</p><h3>5️⃣0️⃣ Group Anagrams</h3><p>🎯 Group words with same letters.<br> 🧠 Use sorted word or frequency key in hashmap.<br> ⏱ O(nk)</p><h3>Final Thought</h3><p>These 50 problems are not random.</p><p>They train:</p><ul><li>Scanning</li><li>Pointer control</li><li>Recursion</li><li>BFS/DFS</li><li>Heap ranking</li><li>DP transitions</li><li>Constraint pruning</li></ul><h3>The 50 Coding Interview Problems That Form My Complete DSA Blueprint</h3><p>You don’t need 500 problems.</p><p>You need the right 50 — deeply understood.</p><p>These 50 questions form a complete mental blueprint across arrays, sliding window, linked lists, trees, graphs, heaps, stacks, and dynamic programming.</p><p>If you understand the goal and thinking process behind each one, you can solve most variations confidently.</p><p>Let’s go.</p><h3>🟢 ARRAYS &amp; HASHING</h3><h3>1️⃣ Two Sum</h3><p>🎯 Goal: Find two numbers adding to target.<br> 🧠 Steps:</p><ol><li>Iterate once.</li><li>Compute complement.</li><li>Check hashmap.</li><li>Store current number.<br> ⏱ O(n) | O(n)</li></ol><h3>2️⃣ 3Sum</h3><p>🎯 Goal: Find unique triplets summing to zero.<br> 🧠 Steps:</p><ol><li>Sort array.</li><li>Fix one element.</li><li>Use two pointers.</li><li>Skip duplicates.<br> ⏱ O(n²) | O(1)</li></ol><h3>3️⃣ Remove Duplicates (Sorted Array)</h3><p>🎯 Goal: Remove duplicates in-place.<br> 🧠 Steps:</p><ol><li>Slow pointer tracks unique.</li><li>Fast pointer scans.</li><li>Overwrite duplicates.<br> ⏱ O(n) | O(1)</li></ol><h3>4️⃣ Contains Duplicate</h3><p>🎯 Goal: Detect repetition.<br> 🧠 Steps:</p><ol><li>Insert into set.</li><li>If already exists → true.<br> ⏱ O(n) | O(n)</li></ol><h3>5️⃣ Find the Duplicate Number</h3><p>🎯 Goal: Find repeated value without modifying array.<br> 🧠 Steps:</p><ol><li>Treat array as linked list.</li><li>Use slow/fast pointers.</li><li>Find cycle entrance.<br> ⏱ O(n) | O(1)</li></ol><h3>6️⃣ Maximum Product Subarray</h3><p>🎯 Goal: Max product of contiguous subarray.<br> 🧠 Steps:</p><ol><li>Track max &amp; min at each step.</li><li>Swap on negative.</li><li>Update global max.<br> ⏱ O(n) | O(1)</li></ol><h3>7️⃣ Merge Intervals</h3><p>🎯 Goal: Merge overlapping intervals.<br> 🧠 Steps:</p><ol><li>Sort by start.</li><li>Compare with last merged.</li><li>Merge if overlapping.<br> ⏱ O(n log n)</li></ol><h3>8️⃣ Longest Consecutive Sequence</h3><p>🎯 Goal: Longest consecutive numbers sequence.<br> 🧠 Steps:</p><ol><li>Store in set.</li><li>Start only at numbers where n-1 not present.</li><li>Count forward.<br> ⏱ O(n)</li></ol><h3>🟡 SLIDING WINDOW</h3><h3>9️⃣ Longest Substring Without Repeating</h3><p>🎯 Goal: Longest unique substring.<br> 🧠 Steps:</p><ol><li>Expand right pointer.</li><li>If duplicate → move left.</li><li>Track max length.<br> ⏱ O(n)</li></ol><h3>🔟 Minimum Window Substring</h3><p>🎯 Goal: Smallest substring containing all chars.<br> 🧠 Steps:</p><ol><li>Expand until valid.</li><li>Shrink while valid.</li><li>Track minimum.<br> ⏱ O(n)</li></ol><h3>1️⃣1️⃣ Find All Anagrams</h3><p>🎯 Goal: All anagram start indices.<br> 🧠 Steps:</p><ol><li>Fixed-size sliding window.</li><li>Frequency comparison.</li><li>Move window one step.<br> ⏱ O(n)</li></ol><h3>1️⃣2️⃣ Permutation in String</h3><p>🎯 Goal: Check if permutation exists.<br> 🧠 Steps:</p><ol><li>Same logic as anagram.</li><li>Return true when match found.<br> ⏱ O(n)</li></ol><h3>1️⃣3️⃣ Longest Palindromic Substring</h3><p>🎯 Goal: Find longest palindrome.<br> 🧠 Steps:</p><ol><li>Expand around each center.</li><li>Track max length.<br> ⏱ O(n²)</li></ol><h3>🔵 LINKED LISTS</h3><h3>1️⃣4️⃣ Reverse Linked List</h3><p>🎯 Reverse in-place.<br> 🧠 Use prev, curr, next pointers.<br> ⏱ O(n)</p><h3>1️⃣5️⃣ Linked List Cycle</h3><p>🎯 Detect cycle.<br> 🧠 Slow &amp; fast pointers.<br> ⏱ O(n)</p><h3>1️⃣6️⃣ Linked List Cycle II</h3><p>🎯 Find cycle start.<br> 🧠 Reset one pointer after meeting.<br> ⏱ O(n)</p><h3>1️⃣7️⃣ Merge Two Sorted Lists</h3><p>🎯 Merge two sorted linked lists.<br> 🧠 Compare nodes and attach smaller.<br> ⏱ O(n)</p><h3>1️⃣8️⃣ Reorder List</h3><p>🎯 Reorder L0→Ln→L1→Ln-1…<br> 🧠 Find middle, reverse second half, merge alternately.<br> ⏱ O(n)</p><h3>🌳 TREES</h3><h3>1️⃣9️⃣ Binary Tree Level Order</h3><p>🎯 BFS traversal.<br> 🧠 Use queue.<br> ⏱ O(n)</p><h3>2️⃣0️⃣ Diameter of Binary Tree</h3><p>🎯 Longest path.<br> 🧠 Post-order DFS, compute height.<br> ⏱ O(n)</p><h3>2️⃣1️⃣ Max Path Sum</h3><p>🎯 Max sum anywhere.<br> 🧠 Ignore negative branches.<br> ⏱ O(n)</p><h3>2️⃣2️⃣ Validate BST</h3><p>🎯 Check BST validity.<br> 🧠 Maintain min/max bounds.<br> ⏱ O(n)</p><h3>2️⃣3️⃣ Lowest Common Ancestor</h3><p>🎯 Find shared ancestor.<br> 🧠 Recurse left &amp; right.<br> ⏱ O(n)</p><h3>2️⃣4️⃣ Invert Binary Tree</h3><p>🎯 Swap children recursively.<br> ⏱ O(n)</p><h3>2️⃣5️⃣ Serialize &amp; Deserialize</h3><p>🎯 Convert tree ↔ string.<br> 🧠 BFS/DFS with null markers.<br> ⏱ O(n)</p><h3>🌐 GRAPHS</h3><h3>2️⃣6️⃣ Number of Islands</h3><p>🎯 Count connected components.<br> 🧠 DFS/BFS mark visited.<br> ⏱ O(mn)</p><h3>2️⃣7️⃣ Rotting Oranges</h3><p>🎯 Time until all rot.<br> 🧠 Multi-source BFS.<br> ⏱ O(mn)</p><h3>2️⃣8️⃣ Course Schedule</h3><p>🎯 Detect cycle.<br> 🧠 Topological sort.<br> ⏱ O(V+E)</p><h3>2️⃣9️⃣ Course Schedule II</h3><p>🎯 Return ordering.<br> 🧠 Kahn’s BFS topo sort.<br> ⏱ O(V+E)</p><h3>3️⃣0️⃣ Clone Graph</h3><p>🎯 Deep copy graph.<br> 🧠 DFS/BFS + visited map.<br> ⏱ O(V+E)</p><h3>3️⃣1️⃣ Shortest Path in Binary Matrix</h3><p>🎯 Shortest path in grid.<br> 🧠 BFS guarantees shortest path.<br> ⏱ O(n²)</p><h3>🔴 BACKTRACKING</h3><h3>3️⃣2️⃣ Word Search</h3><p>🎯 Word exists in grid.<br> 🧠 DFS with backtracking.</p><h3>3️⃣3️⃣ Word Search II</h3><p>🎯 Find multiple words.<br> 🧠 Trie + DFS pruning.</p><h3>3️⃣4️⃣ Sudoku Solver</h3><p>🎯 Solve board.<br> 🧠 Try numbers, validate, backtrack.</p><h3>🟣 HEAPS &amp; STACKS</h3><h3>3️⃣5️⃣ Top K Frequent Elements</h3><p>🎯 Return k frequent.<br> 🧠 Frequency map + heap.<br> ⏱ O(n log k)</p><h3>3️⃣6️⃣ Kth Largest Element</h3><p>🎯 Find kth largest.<br> 🧠 Min-heap or Quickselect.</p><h3>3️⃣7️⃣ Median from Data Stream</h3><p>🎯 Maintain dynamic median.<br> 🧠 Two heaps (max + min).</p><h3>3️⃣8️⃣ 132 Pattern</h3><p>🎯 Detect pattern.<br> 🧠 Traverse from right + monotonic stack.</p><h3>🟠 DYNAMIC PROGRAMMING</h3><h3>3️⃣9️⃣ House Robber</h3><p>🎯 Max non-adjacent sum.<br> 🧠 dp[i] = max(skip, rob).<br> ⏱ O(n)</p><h3>4️⃣0️⃣ Maximum Subarray</h3><p>🎯 Largest sum contiguous.<br> 🧠 Kadane’s algorithm.<br> ⏱ O(n)</p><h3>4️⃣1️⃣ Best Time to Buy/Sell Stock</h3><p>🎯 Max profit.<br> 🧠 Track min price so far.<br> ⏱ O(n)</p><h3>4️⃣2️⃣ Climbing Stairs</h3><p>🎯 Ways to reach top.<br> 🧠 Fibonacci DP.<br> ⏱ O(n)</p><h3>4️⃣3️⃣ Coin Change</h3><p>🎯 Min coins to make amount.<br> 🧠 Bottom-up DP.<br> ⏱ O(n × amount)</p><h3>🟤 CLASSIC PATTERNS</h3><h3>4️⃣4️⃣ Binary Search</h3><p>🎯 Find target in sorted array.<br> 🧠 Divide search space.<br> ⏱ O(log n)</p><h3>4️⃣5️⃣ Spiral Matrix</h3><p>🎯 Traverse in spiral order.<br> 🧠 Maintain boundaries.</p><h3>4️⃣6️⃣ Rotate Image</h3><p>🎯 Rotate matrix 90°.<br> 🧠 Transpose + reverse rows.</p><h3>4️⃣7️⃣ Valid Anagram</h3><p>🎯 Check if strings are anagrams.<br> 🧠 Frequency counting.</p><h3>4️⃣8️⃣ Valid Palindrome</h3><p>🎯 Check if string palindrome.<br> 🧠 Two pointers inward.</p><h3>4️⃣9️⃣ Trie (Prefix Tree)</h3><p>🎯 Efficient prefix search.<br> 🧠 Build tree of characters.</p><h3>5️⃣0️⃣ Group Anagrams</h3><p>🎯 Group words with same letters.<br> 🧠 Use sorted word or frequency key in hashmap.<br> ⏱ O(nk)</p><h3>Final Thought</h3><p>These 50 problems are not random.</p><p>They train:</p><ul><li>Scanning</li><li>Pointer control</li><li>Recursion</li><li>BFS/DFS</li><li>Heap ranking</li><li>DP transitions</li><li>Constraint pruning</li><li>Cycle detection</li></ul><p>Once you recognize structure instead of memorizing answers, interviews become predictable.</p><p>And predictable means manageable.</p><ul><li>Cycle detection</li></ul><p>Once you recognize structure instead of memorizing answers, interviews become predictable.</p><p>And predictable means manageable.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef796cd0d1b6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Logs Are Your System’s Memory and Your Biggest Liability…]]></title>
            <link>https://medium.com/@johnadjanohoun/logs-are-your-systems-memory-and-your-biggest-liability-09488c37efa8?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/09488c37efa8</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Mon, 09 Feb 2026 12:01:01 GMT</pubDate>
            <atom:updated>2026-02-09T12:01:01.447Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/660/1*wBVH5lfNg3KkeLb1WD3xCQ@2x.jpeg" /></figure><h2>Logs are the memory of your system.</h2><p>They tell you what happened, when it happened, and why it happened. They power debugging, reliability, security investigations, and now — more than ever — AI-driven insights.</p><p>But logs are also one of your largest privacy and security liabilities.</p><p>In the age of AI, where logs are fed into analytics engines, copilots, and automated decision systems, mishandling them doesn’t just create operational risk — it creates systemic risk.</p><p>The Downstream Fallacy</p><p>Most teams still treat masking and filtering as a downstream concern:</p><p>•	“We’ll clean it in the observability platform.”</p><p>•	“The SIEM will handle it.”</p><p>•	“We’ll redact it in the data lake.”</p><p>•	“Dashboards won’t show sensitive fields anyway.”</p><p>By the time logs reach those systems, it’s already too late.</p><p>Sensitive data has likely been:</p><p>•	Copied across multiple agents</p><p>•	Buffered in queues and streams</p><p>•	Stored in hot, warm, and cold tiers</p><p>•	Backed up indefinitely</p><p>•	Forwarded to third-party vendors</p><p>•	Indexed, cached, and replicated</p><p>At that point, the blast radius explodes.</p><p>A single leaked API key, session token, email address, IP, or user identifier can quickly turn into a full-blown security incident, expanding audit scope, increasing compliance exposure, and forcing painful retroactive cleanup across systems you don’t fully control.</p><p>Shift Left or Pay Later</p><p>The fix isn’t complicated — it’s architectural.</p><p>Shift left.</p><p>Filter and mask sensitive data as early as possible in the log’s lifecycle:</p><p>•	At the source</p><p>•	Or at the very first collection or processing hop</p><p>This is where you still have context, control, and the smallest surface area.</p><p>Adopt data minimization by default:</p><p>•	Keep what you need to operate</p><p>•	Drop what you don’t</p><p>•	Redact what you must</p><p>If a field isn’t essential for debugging, alerting, or compliance, it doesn’t belong in your logs — especially not in plaintext.</p><p>Why Early Masking Wins</p><p>Shifting left delivers immediate, compounding benefits:</p><p>•	Reduced exposure: Sensitive data never propagates.</p><p>•	Smaller attack surface: Fewer systems can leak what they never received.</p><p>•	Simpler governance: Less data to classify, audit, and justify.</p><p>•	Lower cost: Less storage, indexing, and query overhead.</p><p>•	Cleaner AI inputs: Models trained or assisted by logs see only what they should.</p><p>Most importantly, it turns privacy and security from a reactive cleanup task into a default behavior.</p><p>Make It Boring — and Automatic</p><p>This shouldn’t rely on developer discipline or best intentions.</p><p>Make it:</p><p>•	Automatic</p><p>•	Consistent</p><p>•	Centrally defined</p><p>•	Tested like any other critical system</p><p>Treat log schemas and redaction rules as part of your platform contract, not an afterthought. If it’s not enforced by default, it will eventually be bypassed.</p><p>The AI Reality Check</p><p>In the AI era, logs don’t just explain your system — they teach it.</p><p>If your logs are noisy, over-collected, or full of sensitive data, your AI systems inherit those flaws. They amplify them.</p><p>If your logs can’t be trusted, your AI can’t be either.</p><p>And once trust is gone, no amount of downstream masking will bring it back.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=09488c37efa8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[✈️ Private Pilot Knowledge — Complete Learning Article]]></title>
            <link>https://medium.com/@johnadjanohoun/%EF%B8%8F-private-pilot-knowledge-complete-learning-article-f855da1a7f6c?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/f855da1a7f6c</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Sun, 07 Dec 2025 09:37:59 GMT</pubDate>
            <atom:updated>2025-12-07T09:37:59.846Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/443/1*SIhiDDm8CrTPLqqQJ7Bd5Q.avif" /></figure><h3>✈️ Private Pilot Knowledge — Complete Learning Article</h3><p>Becoming a safe and confident pilot requires mastering a wide range of knowledge: regulations, weather, aerodynamics, airspace, navigation, and aircraft systems.<br> The following article transforms your entire practice test into a coherent aviation learning guide. Each section teaches a concept and incorporates the correct FAA answer as part of the narrative.</p><h3>Transponder &amp; Inspections</h3><p>A transponder must be inspected every 24 calendar months.<br> If the last inspection was performed on September 1, 2014, the latest legal due date is <strong>September 30, 2016</strong>, because inspections expire at the end of the month.</p><h3>Aircraft Categories for Airmen Certification</h3><p>The FAA recognizes four primary aircraft categories for airmen certification: <strong>airplane, rotorcraft, glider, and lighter-than-air</strong>.<br> These differ from <em>classes</em> such as single-engine land or multi-engine sea.</p><h3>Light Gun Signals</h3><p>In case of radio failure, a flashing white light sent to an aircraft on the ground means <strong>return to the starting point on the airport</strong>.</p><h3>VFR Visibility and Cloud Requirements</h3><p>When operating above 1,200 feet AGL but below 10,000 feet MSL in uncontrolled airspace during the day, the minimum required visibility is <strong>1 statute mile</strong>.</p><p>At night, when 1,200 AGL but within 10,000 MSL, you must remain at least <strong>500 feet below</strong> the clouds.</p><h3>Communications at Towered Airports</h3><p>Two-way radio communication is required for takeoff or landing at any towered airport <strong>regardless of weather conditions</strong>.</p><h3>Pilot-in-Command Responsibilities</h3><p>The pilot in command is responsible for <strong>briefing all passengers</strong> on the use of seat belts before takeoff.</p><h3>100-Hour Inspection Calculations</h3><p>If a 100-hour inspection was due at 3302.5 hours and the aircraft actually reached 3309.5 hours before inspection, the next inspection is due <strong>100 hours after 3302.5</strong>, which is <strong>3402.5 hours</strong>.</p><h3>Visual Approach Slope Indicators (VASI)</h3><p>Red over white means the aircraft is <strong>on the glide path</strong>.</p><h3>Basic VFR Cloud Clearance at Low Altitude</h3><p>When operating below 700 feet AGL, compliance with VFR requires <strong>1 mile visibility and clear of clouds</strong>.</p><h3>Weather Briefings</h3><p>When contacting a weather briefer, the pilot should first state whether the flight will be <strong>VFR or IFR</strong>, so the briefer can tailor the report.</p><h3>Frost Hazards</h3><p>Frost is dangerous because it <strong>spoils the smooth airflow over the wings</strong>, reducing lift and significantly increasing drag.</p><h3>Winds Aloft Interpretation</h3><p>A forecast such as “230° at 39 knots” describes <strong>230 degrees true at 39 knots</strong>.</p><h3>Thunderstorm Stages</h3><p>The mature stage of a thunderstorm begins with <strong>the start of precipitation</strong> — the most violent phase, characterized by strong downdrafts and turbulence.</p><h3>Military Operations Areas (MOA)</h3><p>VFR pilots may fly through MOAs but should <strong>exercise extreme caution</strong> due to potentially hazardous military activity.</p><h3>VFR Squawk Code</h3><p>The standard VFR transponder code is <strong>1200</strong>.</p><h3>Wing Flaps Purpose</h3><p>Wing flaps are used to <strong>allow steeper approaches without increasing airspeed</strong>, improving landing performance.</p><h3>Carburetor Icing</h3><p>Carbureted engines are <strong>more susceptible to icing</strong> than fuel-injected engines.</p><h3>Airspeed Indicator Red Line</h3><p>The red line marks <strong>Vne — the never-exceed speed</strong>.</p><h3>LAHSO Authority</h3><p>The pilot in command always has final authority to <strong>accept or decline a Land and Hold Short (LAHSO) clearance</strong>.</p><h3>Manifold Pressure Settings</h3><p>To achieve 65% power at 6,500 feet with the given conditions, the manifold pressure would be <strong>22.1 inches of mercury</strong>.</p><h3>Angle of Attack</h3><p>The angle of attack is defined as the angle between <strong>the chord line of the wing and the relative wind</strong>.</p><h3>VOR CDI Interpretation</h3><p>When the CDI centers with the OBS set to 0°, and the aircraft is on the 180° radial, the indicator should display <strong>FROM</strong>.</p><h3>Non-Towered Communications</h3><p>When the tower is closed, pilots should <strong>monitor airport traffic and announce intentions on 118.5 MHz</strong>.</p><h3>Navigation Facilities</h3><p>Dallas–Fort Worth International Airport (DFW) is served by a <strong>VOR/DME</strong>.</p><h3>Airport Location Interpretation</h3><p>Loup City Municipal Airport lies <strong>east approximately 7 miles</strong> from the city.</p><h3>High-Altitude/High-Temperature Takeoff Decision</h3><p>When density altitude is high and performance is degraded, the best choice is to <strong>wait for the temperature to decrease and recalculate</strong> the takeoff performance.</p><h3>Carb Ice in Fixed-Pitch Propellers</h3><p>The first indication of carburetor ice in a fixed-pitch propeller aircraft is usually <strong>a loss of RPM</strong>.</p><h3>Class of Airspace</h3><p>NALF Fentress (NFE) lies within <strong>Class C airspace</strong>.</p><h3>Emergency Frequency</h3><p>In an emergency when not in contact with ATC, use <strong>121.5 MHz</strong>.</p><h3>Traffic Advisories</h3><p>“Traffic 12 o’clock” is given relative to your <strong>ground track</strong>.</p><h3>Bernoulli’s Principle</h3><p>Lift is produced in part because <strong>air traveling faster over the top of the wing creates lower pressure</strong>.</p><h3>Magnetic Compass Deviation</h3><p>Compass deviation is caused by <strong>electrical systems and metals within the aircraft</strong>.</p><h3>Glide Performance</h3><p>Varying your glide speed during an emergency approach will <strong>reduce your accuracy in judging landing distance</strong>.</p><h3>Distance Calculations</h3><p>An aircraft traveling at 114 knots covers <strong>14.25 nautical miles</strong> in 7.5 minutes.</p><h3>Class C Procedural Outer Area</h3><p>The typical radius of Class C’s procedural outer area is <strong>20 nautical miles</strong>.</p><h3>Density Altitude and Temperature</h3><p>An increase from 35°F to 50°F at constant pressure altitude results in <strong>a 1,000-foot increase</strong> in density altitude.</p><h3>Transponder Codes to Avoid</h3><p>When changing routine codes, pilots must avoid selecting <strong>7500</strong>, which transmits a hijacking signal.</p><h3>Hyperventilation</h3><p>To correct hyperventilation, a pilot should <strong>slow breathing — talk aloud or breathe into a paper bag</strong>.</p><h3>Taxiway Identification Signs</h3><p>A sign with a black background and yellow inscription such as “22” confirms you are <strong>on taxiway 22</strong>.</p><h3>Runway Exit Markings</h3><p>From the cockpit, the marking shown indicates <strong>a runway boundary — about to exit the runway</strong>.</p><h3>Basic VFR Minima at Onawa, IA</h3><p>Daytime VFR requirements there are <strong>3 statute miles visibility and clear of clouds</strong>.</p><h3>RAIM Loss</h3><p>If RAIM becomes unavailable, <strong>GPS position is unreliable</strong>.</p><h3>Weather Briefer Calls</h3><p>A pilot should begin the call by <strong>identifying themselves as a pilot</strong>.</p><h3>Passenger-Carrying Currency</h3><p>To carry passengers, the pilot must have completed three takeoffs and landings within the <strong>preceding 90 days</strong>.</p><h3>Torque Effects</h3><p>Torque effects are greatest at <strong>low airspeed, high power, and high angle of attack</strong>, such as during takeoff.</p><h3>Wind Differences With Altitude</h3><p>Surface winds differ from winds aloft mainly due to <strong>friction between the wind and Earth’s surface</strong>.</p><h3>Visual Scanning Techniques</h3><p>During collision avoidance scanning, the pilot should move their eyes <strong>10 degrees at a time and pause for at least one second</strong>.</p><h3>Temperature Inversions</h3><p>A temperature inversion is when <strong>temperature increases with altitude</strong>, often causing stable air and reduced visibility.</p><h3>Upslope Stable Air</h3><p>Warm, moist, stable air rising upslope tends to produce <strong>stratus clouds</strong>.</p><h3>Pilot Certificate Inspection</h3><p>A pilot certificate must be shown upon request of <strong>local law enforcement officers</strong>, FAA inspectors, or NTSB.</p><h3>ATC Phraseology</h3><p>The correct method to state 5,500 feet MSL is <strong>“Five thousand five hundred.”</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f855da1a7f6c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[️ 60 Essential Knowledge Points Every Private Pilot Must Know (FAA PPL Study Guide)]]></title>
            <link>https://medium.com/@johnadjanohoun/%EF%B8%8F-60-essential-knowledge-points-every-private-pilot-must-know-faa-ppl-study-guide-54d1af424d72?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/54d1af424d72</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Wed, 29 Oct 2025 08:58:12 GMT</pubDate>
            <atom:updated>2025-10-29T08:58:12.037Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>By Jean Claude Adjanouhoun</em></strong></p><p><strong>Preparing for your FAA Private Pilot Knowledge Test?<br> Here’s a compact, easy-to-read version of the most essential concepts — simplified for understanding and perfect for study sessions, podcasts, or quick memory refreshers before checkride day.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/805/0*BRfc130EPAYTUbyk.png" /></figure><h3>✈️ 1–10: The Foundation of Communication and Weather</h3><p>1️⃣ When calling Flight Service, identify as a pilot, give your aircraft ID, and specify if it’s VFR or IFR.<br> 2️⃣ Frost forms when both surface and dewpoint are below freezing — remove before flight.<br> 3️⃣ Angle of attack is between the wing’s chord line and the relative wind.<br> 4️⃣ Unstable air = turbulence and clear visibility.<br> 6️⃣ High engine temps cause power loss and engine damage.<br> 7️⃣ “Nimbus” means rain cloud.<br> 8️⃣ Uneven S-turns mean poor wind correction.<br> 9️⃣ Spatial disorientation happens when flying VFR into IMC — trust instruments.<br> 10️⃣ Available Landing Distance (LAHSO) info is in the Chart Supplement.</p><h3>🌤️ 11–20: Weather, Stability, and Basic Flight Handling</h3><p>11️⃣ Dewpoint = temperature air must cool to reach saturation.<br> 12️⃣ ATIS gives continuous noncontrol info to reduce radio congestion.<br> 13️⃣ A thunderstorm’s mature stage starts with the first rainfall.<br> 15️⃣ Longitudinal stability = CG relative to lift.<br> 16️⃣ Enter traffic pattern 45° to downwind leg at pattern altitude.<br> 17️⃣ Constant glide speed = accurate emergency landing judgment.<br> 18️⃣ Lowering altimeter 30.11 → 29.96 = 150 ft lower reading.<br> 19️⃣ Taxiing with left-quartering tailwind: left aileron up, elevator down.<br> 20️⃣ Warm air holds more moisture than cold air.</p><h3>🧭 21–30: Regulations and Airspace Awareness</h3><p>21️⃣ VFR transponder code = 1200.<br> 23️⃣ Airworthiness Certificate valid as long as aircraft is maintained properly.<br> 24️⃣ Under BasicMed, carry driver’s license + course certificate.<br> 25️⃣ Pilot in Command = final authority.<br> 26️⃣ First-class medical for a 23-year-old = valid until end of next October.<br> 27️⃣ No Special VFR at DFW Intl or Love Field (Class B).<br> 29️⃣ Hyperventilation: slow breathing or breathe into bag.<br> 30️⃣ Severe icing (not convective) = SIGMET.</p><h3>☁️ 31–40: Weather, Planning, and Performance</h3><p>31️⃣ Clouds grouped by height: high, middle, low, towering.<br> 32️⃣ High temps + altitude increase takeoff roll.<br> 33️⃣ Include climb and wind correction in flight-time estimates.<br> 34️⃣ Report DUI/drug driving convictions to FAA within 60 days.<br> 35️⃣ At night, scan slowly — use off-center vision.<br> 36️⃣ BasicMed course valid 2 years (to end of month).<br> 37️⃣ Warm fronts bring layered clouds, smooth air.<br> 39️⃣ Always have an alternate plan if flight can’t be completed.<br> 40️⃣ Fill fuel tanks after flight to avoid condensation.</p><h3>🛫 41–50: Airspeed, Systems, and Emergency Awareness</h3><p>41️⃣ On a magnetic course of 175°, VFR altitude = 5,500 ft (odd + 500).<br> 42️⃣ Pitot blockage = airspeed indicator failure.<br> 43️⃣ Monitor CTAF ~10 miles from uncontrolled airports.<br> 45️⃣ Only the PIC may accept or decline a LAHSO clearance.<br> 46️⃣ Parachute jump areas listed in Chart Supplement.<br> 47️⃣ PIC must brief passengers on seatbelts for taxi, takeoff, landing.<br> 48️⃣ True course measured from true north.<br> 49️⃣ CG = total moment ÷ total weight.<br> 50️⃣ First sign of carb ice = gradual loss of RPM.</p><h3>🌙 51–60: Airmanship, Weather, and Safety</h3><p>51️⃣ Night landings: same approach as daytime.<br> 52️⃣ On a plotter, zero miles not at physical edge.<br> 53️⃣ Winds aloft = true direction, knots, temp in °C.<br> 54️⃣ Empty weight includes airframe, engine, unusable fuel, undrainable oil.<br> 55️⃣ Haze makes objects appear farther away.<br> 56️⃣ GPS uses 24 satellites.<br> 57️⃣ Over-breathing on oxygen = hyperventilation.<br> 59️⃣ Maneuvering speed (Va) isn’t color-coded on airspeed indicator.<br> 60️⃣ Any airplane can hydroplane on a wet runway.</p><h3>🧠 Final Thought</h3><p>Flying isn’t about memorizing trivia — it’s about mastering awareness.<br> Each of these points represents a building block of safe airmanship.<br> Read them aloud, visualize them in flight, and repeat them until they become instinct.</p><p><strong>Knowledge saves lives.</strong><br> And as every pilot learns early: altitude, airspeed, and awareness — never run out of all three.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=54d1af424d72" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Policy to Pipelines: Meta’s Data Engineers on Transparency.]]></title>
            <link>https://medium.com/@johnadjanohoun/from-policy-to-pipelines-metas-data-engineers-on-transparency-3daeb989e6e6?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/3daeb989e6e6</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Sat, 27 Sep 2025 05:05:31 GMT</pubDate>
            <atom:updated>2025-09-27T05:05:31.402Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/645/1*gm8U3NXLC_glGanZUa9gzg@2x.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*sawHbaVtfxpOo1cyaMRiHg@2x.jpeg" /></figure><p>Introduction</p><p>Transparency at Meta is more than a principle — it’s a responsibility. Every day, billions of people use Meta’s platforms, and with that scale comes the obligation to explain clearly how harmful content is detected, reviewed, and acted upon. Regulations like the EU’s Digital Services Act have raised the bar, demanding detailed reporting that shows not just what was removed, but how it was handled end-to-end.</p><p>The Challenge of Scale</p><p>At first glance, it might sound simple to report numbers like “how many bullying posts were removed last month.” In reality, each number hides layers of complexity:</p><p>•	Should a carousel with five images be counted as one post or five?</p><p>•	Does reducing a post’s reach count the same as removing it?</p><p>•	Should we attribute enforcement to machine-learning systems or to user reports?</p><p>•	When tallying by geography, do we use the poster’s home country or their location at the time of posting?</p><p>Meta’s data engineers confront these questions daily, ensuring that the way metrics are defined is consistent, rigorous, and meaningful.</p><p>Turning Policy Into Systems</p><p>Policies like “hate speech” or “bullying” may sound straightforward, but operationalizing them requires precision. Meta’s engineers create canonical definitions that unify multiple enforcement systems into one standardized reporting framework.</p><p>To guarantee accountability, governance rules are applied upstream. If an enforcement action lacks essential information — like user notification or appeal rights — the system won’t let it proceed. This approach ensures transparency is embedded in the enforcement process itself, not added later as an afterthought.</p><p>The Enforcement Funnel</p><p>To make sense of enforcement at scale, Meta models the process as a funnel with five stages:</p><p>1.	Observation — capturing activity across platforms.</p><p>2.	Detection — flagging potential violations, via automation or user reports.</p><p>3.	Decisioning — determining which policy applies.</p><p>4.	Actioning — applying the chosen enforcement (removal, demotion, labeling).</p><p>5.	User Experience — notifying users and allowing appeals.</p><p>This funnel brings structure to an otherwise complex ecosystem and makes reporting consistent across regions and regulations.</p><p>Data Pipelines Built for Trust</p><p>At the heart of transparency reporting is Integrity Core Data — a privacy-safe, unified dataset that captures enforcement events in detail. From there, Meta’s engineers design reporting pipelines guided by four principles:</p><p>•	Auditability: every metric can be traced back through its transformations.</p><p>•	Consistency: the same number appears across dashboards, reports, and regulator filings.</p><p>•	Monitoring: anomalies are caught early with built-in validation.</p><p>•	Version control: once a report is published, the numbers stay frozen, even as definitions evolve.</p><p>By combining engineering discipline with governance, Meta can meet deadlines and maintain trust in its disclosures.</p><p>Lessons Learned</p><p>Over years of building these systems, Meta’s data engineers have learned key lessons:</p><p>•	Transparency is a product: it needs its own roadmap, resources, and accountability.</p><p>•	Change is constant: definitions, regulations, and expectations will keep evolving.</p><p>•	Quality comes first: accuracy matters more than speed.</p><p>•	Automation reduces risk: standardized rules and reusable definitions lower human error.</p><p>Looking Ahead</p><p>The work is ongoing. Meta is investing in:</p><p>•	Automation to streamline reporting and governance.</p><p>•	Self-serve tools to empower teams beyond engineering.</p><p>•	AI-assisted discovery that makes metrics easier to explore.</p><p>•	A Canonical Metric Menu — a single source of truth for all official numbers.</p><p>Conclusion</p><p>From policy definitions to data pipelines, Meta’s data engineers are building systems that make transparency measurable, auditable, and scalable. By treating transparency as a product in its own right, they’re helping ensure accountability keeps pace with the scale of Meta’s platforms.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3daeb989e6e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Inside Meta’s Data Engineering: A Comprehensive Look at the Internal Tech Stack]]></title>
            <link>https://medium.com/@johnadjanohoun/inside-metas-data-engineering-a-comprehensive-look-at-the-internal-tech-stack-aeb0e8903cc1?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/aeb0e8903cc1</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Sat, 13 Sep 2025 20:50:44 GMT</pubDate>
            <atom:updated>2025-09-13T20:50:44.515Z</atom:updated>
            <content:encoded><![CDATA[<p><strong><em>By Jean Claude Adjanouhoun.</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cTvYCWrzoxFk3UDVQmqzmw.jpeg" /></figure><p>Data engineering at Meta operates at a scale few organizations in the world can imagine. With an exabyte-sized data warehouse, countless pipelines, and a culture built around efficiency and privacy, Meta’s engineers have developed an ecosystem of tools that transforms raw data into actionable insights powering both product decisions and business outcomes.</p><p>This article takes a deeper look at the systems Meta’s data engineers use daily: from the warehouse itself to discovery tools, real-time analytics, pipeline orchestration, and monitoring. Along the way, it highlights the principles of modularity, scalability, and privacy awareness that shape how Meta handles data.</p><h3>The Heart of the System: Meta’s Data Warehouse</h3><p>At the center of Meta’s analytics lies the data warehouse, a massive repository that is distinct from the graph database (TAO) which powers real-time content delivery. The warehouse is so large — measured in exabytes — that it cannot be contained within a single data center. Instead, it is distributed across multiple geographies.</p><p>To manage this complexity, the warehouse is divided into namespaces. These serve as both geographic and logical partitions. Data with similar themes is grouped within the same namespace, enabling queries to be executed efficiently without unnecessary cross-region transfers. When cross-namespace queries are required, engineers can replicate tables between namespaces with just a few clicks. These replicas are automatically kept in sync, ensuring reliability.</p><p>Individual tables within the warehouse are partitioned as well, most commonly by date in the form of a ds column written as YYYY-MM-DD. Retention policies control how long data remains available. For example, partitions older than ninety days might be archived into anonymized cold storage or deleted entirely. Each table is also linked to an on-call ownership group, ensuring accountability and clear points of contact.</p><h3>How Data Enters the Warehouse</h3><p>The warehouse is fed through three primary channels. Data pipelines and workflows — often managed by the internal framework Dataswarm — pull and transform information from other tables. Server-side and client-side logging frameworks generate streams of valuable usage data. Finally, daily snapshots of entities in the production graph database capture structured states that provide up-to-date context for analysis.</p><p>Together, these flows ensure the warehouse reflects both the real-time activity of Meta’s platforms and longer-term business metrics.</p><h3>Finding the Right Data: iData</h3><p>With millions of tables in play, discovery is critical. Meta’s engineers rely on an internal tool called iData, which functions like a search engine for the warehouse. Engineers enter a keyword, and iData ranks results intelligently by taking into account freshness, level of documentation, number of downstream usages, and even mentions in internal discussions.</p><p>More advanced searches allow filtering by specific columns, on-call groups, or table ownership. Lineage visualization adds another layer, showing both upstream data sources and downstream consumers. This enables engineers not just to locate data but also to understand its dependencies and impact.</p><h3>Querying at Scale: Presto and Spark</h3><p>Once data has been located, engineers query it primarily using Presto and Spark. Presto, which was originally developed at Meta and later open-sourced, is typically used for fast, interactive queries. Clusters are sized so that scanning billions of rows is often a matter of seconds, making it highly efficient for ad hoc analysis.</p><p>Spark, on the other hand, is employed for heavier workloads that require large amounts of memory or involve expensive joins. While the majority of pipelines are written in SQL — either Presto SQL or Spark SQL — Meta also makes use of Spark’s APIs in Python, Scala, or Java to manage more complex transformations. This balance ensures that engineers have both speed and flexibility depending on the workload.</p><h3>Real-Time Insights: Scuba</h3><p>Batch pipelines cannot always meet the need for immediate feedback. For real-time analytics, engineers turn to Scuba, Meta’s internal framework designed to monitor logs and short-term trends. Scuba is widely used for debugging and quick investigations into live issues.</p><p>It can be accessed through a web interface similar to Kibana, allowing rapid visualization without writing queries, or through a SQL-like syntax for more detailed analysis. To optimize for cost, Scuba ingests only a fraction of logs, while the full dataset is stored in Hive. This makes it ideal for fast exploration of recent activity while preserving long-term completeness elsewhere.</p><h3>Notebook Workflows: Daiquery and Bento</h3><p>Meta’s engineers rely heavily on notebook-style environments to iterate quickly and visualize results. Daiquery is the lightweight entry point. It supports multiple query sources — including Presto, Spark, and Scuba — and allows engineers to write queries, visualize results, and refine them rapidly.</p><p>For more advanced analysis, Daiquery notebooks can be promoted to Bento, Meta’s managed Jupyter environment. Bento supports Python, R, custom kernels, and a wide array of visualization libraries. It is used not only by data engineers but also by data scientists and machine learning engineers running experiments and building workflows. Together, Daiquery and Bento create a continuum from quick iteration to advanced modeling.</p><h3>Dashboards and Visualization: Unidash</h3><p>Insights are most useful when shared, and dashboards are the medium of choice at Meta. Engineers build them using Unidash, the company’s internal dashboarding platform. Queries and visualizations created in Daiquery can be promoted directly into Unidash dashboards, streamlining the workflow.</p><p>Performance is a major concern at Meta’s scale, so dashboards often rely on pre-aggregated data. When this is not feasible, engineers turn to RaptorX, an extension of Presto that caches commonly used data and accelerates queries by up to ten times. This ensures that dashboards remain responsive, even when backed by extremely large datasets.</p><h3>Building Pipelines: Dataswarm and UPM</h3><p>At the heart of Meta’s data engineering work is the ability to define and orchestrate pipelines. This is done with Dataswarm, Meta’s internally developed orchestration and scheduling framework, which predates Apache Airflow. While Airflow has become the industry standard, Dataswarm has been evolving inside Meta for years, and the two share many of the same core principles.</p><p>Pipelines in Dataswarm are defined as directed acyclic graphs, or DAGs. Each node in the DAG represents an operator, and operators can be chained together to express dependencies. Operators come in several types: some wait for upstream partitions to arrive, some execute queries on Presto or Spark, some perform data quality checks, others transfer data between systems, and a few handle miscellaneous tasks like triggering alerts or sending notifications.</p><p>A pipeline is typically written in SQL wrapped in Python code. The SQL encodes the business logic for transformations, while Python handles orchestration and scheduling. Engineers write pipeline definitions in a customized version of Visual Studio Code, which comes with internal plugins. These plugins lint the SQL, preview the DAG, and even allow engineers to schedule test runs using real input data but with outputs written to temporary tables.</p><p>Dataswarm is flexible enough to allow pipelines to scale massively, but it’s also designed to reduce repetitive work. One of the major advances in recent years has been the Unified Programming Model, or UPM. Instead of requiring engineers to manually declare every dependency, UPM parses the SQL queries in a pipeline and automatically infers which partitions and upstream tables are required. This means that engineers no longer need to duplicate logic between query code and orchestration code. They can focus on the core business logic, while Dataswarm and UPM handle dependency management.</p><p>Dataswarm has been around long enough that it has a history of its own. Back in 2014, a Meta engineer presented its design publicly on YouTube, and while the system has evolved significantly since then, the base principles remain. Over time, teams have added features like analytics libraries, which generate common types of pipelines — such as digest-style tables using HyperLogLog approximate counters — without engineers having to build them from scratch.</p><p>The end result is a pipeline framework that is deeply integrated into Meta’s culture of scale, automation, and efficiency, ensuring that data engineers spend more time on insights and less time on repetitive orchestration.</p><h3>Monitoring and Operations: CDM</h3><p>Running thousands of pipelines requires robust monitoring. Meta uses CDM, the Central Data Manager, as its main operational tool. CDM goes beyond a standard Airflow-like interface, providing an entry point for diagnosing failures, tracing dependencies, and ensuring service-level agreements are met.</p><p>Engineers can identify failing tasks, backfill missing data, trace recursive upstream blockers, and configure notifications when deadlines are at risk. CDM also integrates data quality checks to validate outputs and tracks historical pipeline performance. This makes it a vital safeguard for Meta’s data reliability.</p><h3>Beyond Pipelines: Broader Engineering Work</h3><p>Not every data engineer at Meta spends their time solely on pipelines and dashboards. Some focus on logging frameworks, while others build experimental testing tools or specialize in managing machine learning workloads.</p><p>The engineering environment supports this diversity of work. Meta operates with a near-monorepo structure and uses Sapling, an open-source fork of Mercurial, for version control. Most engineers work with a heavily customized version of Visual Studio Code, enhanced with internal extensions for linting, validation, and DAG visualization. This unified environment fosters collaboration while enabling engineers to branch into specialized areas.</p><h3>Looking Ahead</h3><p>Meta’s data infrastructure continues to evolve. Current initiatives emphasize building privacy-aware systems to comply with global regulations, lowering query and storage costs to improve efficiency, and simplifying pipeline management to reduce repetitive work. The overarching goal is to free engineers from operational overhead so they can focus on delivering insights that matter.</p><h3>Closing Thoughts</h3><p>Meta’s data engineering landscape is defined by its scale, complexity, and sophistication. From an exabyte-scale warehouse to real-time debugging tools, the stack reflects years of iteration and innovation. Engineers must constantly balance technical excellence with business impact, ensuring that data remains accessible, reliable, and compliant.</p><p>At its core, Meta’s approach to data engineering is about empowerment: enabling teams across the company to make better, faster, and more informed decisions by giving them access to data that is both trustworthy and actionable.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aeb0e8903cc1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Don’t Just LeetCode Understand the Coding Interview Format.]]></title>
            <link>https://medium.com/@johnadjanohoun/dont-just-leetcode-understand-the-coding-interview-format-386152a88ab6?source=rss-d7e07444c841------2</link>
            <guid isPermaLink="false">https://medium.com/p/386152a88ab6</guid>
            <dc:creator><![CDATA[Jean claude adjanohoun]]></dc:creator>
            <pubDate>Mon, 01 Sep 2025 19:09:02 GMT</pubDate>
            <atom:updated>2025-09-01T19:09:02.625Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nGHjnvFwJJ6ZmWly4cEAjw@2x.jpeg" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*g1-uf4sqhOddx6EwhoFgWw@2x.jpeg" /></figure><p>Many aspiring software engineers make the mistake of solely focusing on solving problems on LeetCode. While practicing coding problems is crucial, it’s not enough to ace technical interviews. What truly sets top candidates apart is their understanding of the interview format and what the interviewer expects from them.</p><p>A coding interview isn’t just about solving problems — it’s about problem-solving communication, structured thinking, and collaboration. To maximize your chances of success, follow this structured approach:</p><ol><li>Ask for Clarifications</li></ol><p>Before jumping into coding, clarify key details:</p><p>•	What are the constraints? (e.g., input size, negative values, edge cases)</p><p>•	What is the expected input and output? (e.g., list, string, integer)</p><p>•	Are there any assumptions? (e.g., should the input always be valid?)</p><p>•	Should I optimize for time or space complexity?</p><p>Asking the right questions shows your attention to detail and ensures you don’t make incorrect assumptions.</p><p>2. Discuss Multiple Approaches and Trade-offs</p><p>Before coding, explore different ways to solve the problem:</p><p>•	Brute-force approach: What’s the simplest way to solve this? What’s its time complexity?</p><p>•	Optimized approach: How can I improve it? Can I use a different data structure?</p><p>•	Trade-offs: Does the optimized approach use more memory? Is it harder to implement?</p><p>This step shows your analytical thinking and ability to make informed decisions.</p><p>3. Get Buy-In Before Coding</p><p>Once you’ve discussed multiple approaches, align with your interviewer on which one you’ll implement. This prevents wasted time coding a solution they didn’t expect. A simple “Does this approach look good to you?” can save you from going down the wrong path.</p><p>4. Communicate While Coding</p><p>When writing code, think out loud:</p><p>•	Explain what each function and variable does.</p><p>•	Describe why you’re implementing logic in a certain way.</p><p>•	Break down complex operations into simple steps.</p><p>Your interviewer isn’t just evaluating your coding skills — they want to see how well you articulate your thought process.</p><p>5. Dry Run Your Code with a Test Case</p><p>Before saying “I’m done,” walk through your code manually:</p><p>•	Use a simple test case and track variable changes as if debugging.</p><p>•	Check for edge cases (empty input, duplicates, negative numbers, etc.).</p><p>•	Identify and fix any logic errors before running the code.</p><p>This step demonstrates attention to detail and helps catch mistakes early.</p><p>Final Thoughts</p><p>Technical interviews aren’t just about solving problems — they’re about demonstrating problem-solving skills, structured thinking, and communication. Practicing LeetCode is great, but if you don’t follow the right interview format, you might struggle even with problems you know how to solve.</p><p>Next time you prepare for an interview, focus not just on what you solve, but also on how you approach it. That’s what truly impresses interviewers.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=386152a88ab6" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>