<?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 Sade Shure Garmamo on Medium]]></title>
        <description><![CDATA[Stories by Sade Shure Garmamo on Medium]]></description>
        <link>https://medium.com/@Sade_Shure?source=rss-3fb49f1e0513------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*Lf6g4EuGesq7wo1Sn1in3g.jpeg</url>
            <title>Stories by Sade Shure Garmamo on Medium</title>
            <link>https://medium.com/@Sade_Shure?source=rss-3fb49f1e0513------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 21:12:35 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@Sade_Shure/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[Mastering Retrieval-Augmented Generation (RAG): From Beginner to Advanced]]></title>
            <link>https://towardsdev.com/mastering-retrieval-augmented-generation-rag-from-beginner-to-advanced-52ae1294e311?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/52ae1294e311</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[retrieval-augmented-gen]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[agentic-rag]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Mon, 29 Jun 2026 12:11:10 GMT</pubDate>
            <atom:updated>2026-07-03T07:17:26.444Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*L1B3gVQfaepJk23h.jpg" /><figcaption>Understading RAG</figcaption></figure><p>Part 1: What is RAG? Why Every AI Engineer Should Learn It</p><p><em>“A Large Language Model is only as useful as the knowledge it can access.”</em></p><p>Artificial Intelligence has evolved at an extraordinary pace. In just a few years, Large Language Models (LLMs) such as GPT, Llama, Gemini, and Claude have transformed how we search for information, write software, analyze data, and automate business processes.</p><p>Today, AI can generate code, summarize lengthy documents, translate between languages, answer complex questions, and even assist with scientific research. These capabilities have fueled the rapid adoption of AI across industries such as healthcare, banking, education, legal services, travel, and software engineering.</p><p>However, despite their remarkable abilities, LLMs have a fundamental limitation:</p><p><strong>They don’t actually know your organization’s data.</strong></p><p>They cannot read your company’s internal documents unless you explicitly provide them. They cannot automatically answer questions about products released after their training period. Most importantly, they sometimes generate answers that sound convincing but are factually incorrect.</p><p>This phenomenon is known as <strong>AI hallucination</strong>, and it is one of the biggest challenges when deploying AI in production.</p><p>To solve this problem, researchers introduced <strong>Retrieval-Augmented Generation (RAG), </strong>an architecture that combines the reasoning capabilities of LLMs with external knowledge retrieval. Rather than relying solely on what the model memorized during training, a RAG system retrieves relevant information from trusted sources at query time and uses that information to generate grounded, up-to-date responses.</p><p>In this first article, you’ll learn:</p><ul><li>What Retrieval-Augmented Generation (RAG) is</li><li>Why traditional LLMs are limited</li><li>How RAG solves these limitations</li><li>Real-world applications of RAG</li><li>RAG versus Fine-Tuning</li><li>Why RAG has become a cornerstone of modern enterprise AI</li></ul><p>By the end of this article, you’ll understand why nearly every production AI system today incorporates some form of RAG.</p><h4><strong>Before We Learn RAG, Let’s Understand LLMs</strong></h4><p>Imagine you ask an AI assistant:</p><blockquote>“What is the latest mortgage interest policy at my bank?”</blockquote><p>If that policy was published yesterday, there’s a good chance the model won’t know it. Its response will be based only on what it learned during training.</p><p>Large Language Models are trained on enormous datasets containing books, articles, websites, code repositories, and other publicly available text. During training, they learn statistical relationships between words and concepts, enabling them to generate fluent, human-like responses.</p><p>However, once training is complete, the model’s knowledge becomes largely fixed. It does not continuously learn from newly published information or automatically gain access to private organizational data.</p><p>Think of an LLM as a brilliant graduate who finished university last year. They possess extensive knowledge but won’t know about today’s company policies or yesterday’s product launch unless someone shares that information with them.</p><p>This leads to several practical limitations.</p><h4>The Four Major Limitations of Traditional LLMs</h4><h3>1. Knowledge Cutoff</h3><p>Every LLM has a point in time after which it has no inherent knowledge.</p><p>If you ask about recent events, updated regulations, or newly released products, the model may not provide accurate information because it was never trained on that data.</p><h3>2. Hallucinations</h3><p>LLMs are designed to predict the next most likely word, not to verify facts.</p><p>As a result, they may confidently generate information that is incorrect, fabricated, or unsupported.</p><p>For example:</p><p><strong>Question</strong></p><blockquote><em>“Who is the CEO of ABC Bank?”</em></blockquote><p>If the model lacks reliable information, it may invent a plausible answer instead of admitting uncertainty.</p><p>Hallucinations are especially problematic in domains such as healthcare, finance, legal services, and cybersecurity, where factual accuracy is essential.</p><h3>3. No Access to Private Data</h3><p>Organizations store knowledge in many places:</p><ul><li>PDF documents</li><li>Microsoft Word files</li><li>Databases</li><li>SharePoint</li><li>Wikis</li><li>Emails</li><li>Internal APIs</li><li>Cloud storage</li></ul><p>A general-purpose LLM cannot access these resources unless they are explicitly connected through an application.</p><h3>4. Expensive Fine-Tuning</h3><p>One approach to teaching an LLM new information is fine-tuning. While useful for adapting model behavior, it is not an efficient solution for frequently changing knowledge.</p><p>Imagine updating a company’s knowledge base every day and retraining a large model after each change. This would be slow, expensive, and operationally challenging.</p><p>Organizations need a way to keep AI responses current without constantly retraining the model.</p><h3>So, what is Retrieval-Augmented Generation (RAG)?</h3><p>Retrieval-Augmented Generation (RAG) is an AI architecture that enhances an LLM by retrieving relevant information from external knowledge sources before generating a response.</p><p>Instead of answering purely from its internal parameters, a RAG system first searches a trusted knowledge base, retrieves the most relevant information, and includes that context in the prompt sent to the LLM. The model then generates an answer grounded in the retrieved evidence.</p><p>In simple terms:</p><p><strong>Traditional LLM</strong></p><p>Question → LLM → Answer</p><p><strong>RAG</strong></p><p>Question → Search Knowledge Base → Retrieve Relevant Information → LLM → Grounded Answer</p><p>The key difference is that the LLM is no longer relying only on memory, it is consulting an external source of truth before responding.</p><h3>An Everyday Analogy</h3><p>Imagine you’re taking an open-book exam.</p><p>Without RAG, you’re answering every question from memory. You might remember correctly, but you might also forget details or make mistakes.</p><p>With RAG, you’re allowed to consult your textbook before answering. You still use your reasoning skills, but your answers are supported by reliable reference material.</p><p>This is exactly how RAG improves AI systems.</p><h3>Why RAG Matters</h3><p>RAG provides several important benefits:</p><ul><li>Access to up-to-date information</li><li>Reduced hallucinations</li><li>Support for proprietary organizational knowledge</li><li>Improved factual grounding</li><li>Greater transparency through source-backed responses</li><li>Lower operational cost than frequent retraining for changing knowledge bases</li></ul><p>These advantages have made RAG one of the most widely adopted approaches for enterprise AI applications.</p><h3>Real-World Applications of RAG</h3><p>RAG is used across many industries.</p><h3>Banking</h3><ul><li>Customer support assistants</li><li>Loan policy search</li><li>Compliance document retrieval</li><li>Fraud investigation assistants</li></ul><h3>Healthcare</h3><ul><li>Clinical guideline assistants</li><li>Medical research search</li><li>Hospital knowledge assistants</li></ul><h3>Legal</h3><ul><li>Contract analysis</li><li>Case law retrieval</li><li>Regulatory compliance</li></ul><h3>Travel</h3><ul><li>Flight policy assistants</li><li>Booking support</li><li>Travel recommendation systems</li></ul><h3>Software Engineering</h3><ul><li>Documentation chatbots</li><li>API assistants</li><li>Internal developer copilots</li></ul><p>Wherever organizations need AI to answer questions using trusted, current, or proprietary information, RAG is often the preferred solution.</p><h3>RAG vs Fine-Tuning</h3><p>A common misconception is that RAG replaces fine-tuning.</p><p>In reality, they solve different problems.</p><p><strong>RAG</strong> gives the model access to external knowledge at inference time, making it ideal for frequently changing or proprietary information.</p><p><strong>Fine-tuning</strong> changes the model’s behavior or expertise through additional training, making it useful for domain-specific styles, tasks, or reasoning patterns.</p><p>Many enterprise AI systems combine both approaches: fine-tuning for behavior and RAG for knowledge.</p><h3>Key Takeaways</h3><p>By now, you should understand that:</p><ul><li>LLMs are powerful but have limitations.</li><li>Hallucinations and outdated knowledge are major challenges.</li><li>Organizations need AI systems that can access trusted, current information.</li><li>RAG enables this by combining retrieval with generation.</li><li>RAG has become a foundational architecture for production AI systems.</li></ul><p>In the next article, we’ll move from theory to practice by exploring the internal architecture of a RAG system, including document loaders, chunking, embeddings, vector databases, retrievers, prompt construction, and how these components work together to produce accurate, grounded answers.</p><p>The journey has just begun. Happy Reading!!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=52ae1294e311" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/mastering-retrieval-augmented-generation-rag-from-beginner-to-advanced-52ae1294e311">Mastering Retrieval-Augmented Generation (RAG): From Beginner to Advanced</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[IEC 62443: The Global Gold Standard for Securing Industrial Automation and Control Systems]]></title>
            <link>https://towardsdev.com/iec-62443-the-global-gold-standard-for-securing-industrial-automation-and-control-systems-8bf13e970d01?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/8bf13e970d01</guid>
            <category><![CDATA[iec-62443]]></category>
            <category><![CDATA[end-to-end-security]]></category>
            <category><![CDATA[industrial-cyber-security]]></category>
            <category><![CDATA[iso-27000]]></category>
            <category><![CDATA[secure-sdlc]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Tue, 24 Mar 2026 11:10:43 GMT</pubDate>
            <atom:updated>2026-03-24T15:12:42.598Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/474/0*JKfa7Y3mmXfG5Ojp" /><figcaption>IEC 62443</figcaption></figure><p>In an era where cyber threats to critical infrastructure make headlines almost weekly, protecting Operational Technology (OT) has never been more urgent. Factories, power plants, water treatment facilities, and oil refineries rely on Industrial Automation and Control Systems (IACS) that directly control physical processes — and a single breach can halt production, damage equipment, or even endanger lives. Enter IEC 62443 (also known as ISA/IEC 62443), the world’s only consensus-based international series of standards dedicated to cybersecurity for these systems.</p><p><strong>Why IEC 62443 Matters in 2026</strong></p><p>Cyberattacks on industrial systems are escalating in sophistication and impact. Ransomware targeting manufacturing, state-sponsored intrusions into energy grids, and supply-chain compromises are no longer hypothetical. Regulations like the EU’s Cyber Resilience Act (CRA) and growing demands for OT security in critical infrastructure make compliance essential.</p><p>IEC 62443 stands out because it:</p><ul><li>Focuses specifically on IACS (unlike general IT standards such as ISO 27001).</li><li>Emphasizes <strong>availability and integrity</strong> alongside confidentiality — critical when downtime can cost millions or cause safety incidents.</li><li>Supports shared responsibility across <strong>asset owners</strong>, <strong>system integrators</strong>, <strong>service providers</strong>, and <strong>product suppliers</strong>.</li></ul><h3>The Structure of IEC 62443: Four Pillars for Comprehensive Security</h3><p>The standard is organized into four logical groups, each targeting a different audience and phase of the security journey.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*kqJdfwy2Ae5BnTGx.png" /><figcaption>IEC 62443 — SyC Smart Energy</figcaption></figure><p><strong>1. General (62443–1-x)</strong> Foundational concepts, terminology, models, and metrics that everyone uses. Key documents include 62443–1–1 (concepts and models), 1–2 (master glossary), 1–3 (conformance metrics), and 1–4 (IACS security lifecycle).</p><p><strong>2. Policies &amp; Procedures (62443–2-x)</strong> Focuses on organizational programs.</p><ul><li>62443–2–1 (updated 2024): Security program requirements for asset owners — now includes a maturity model.</li><li><strong>New in 2025</strong>: ISA-TR62443–2–2: Guidance on building, validating, and maintaining a comprehensive <strong>Security Protection Scheme (SPS)</strong>.</li><li>2–3: Patch management, 2–4: Requirements for service providers.</li><li>2–5: Implementation guidance.</li></ul><p><strong>3. System (62443–3-x)</strong> System-level design and operation.</p><ul><li>3–2: Security risk assessment and system design (zones &amp; conduits).</li><li>3–3: System security requirements and <strong>Security Levels (SL)</strong>.</li></ul><p><strong>4. Component (62443–4-x)</strong> Product development and technical requirements for suppliers.</p><ul><li>4–1: Secure product development lifecycle.</li><li>4–2: Technical security requirements for IACS components.</li></ul><h3>Core Concepts That Make IEC 62443 Powerful</h3><h4>Zones and Conduits: The Foundation of Segmentation</h4><p>Inspired by (but not limited to) the Purdue Model, IEC 62443 divides the plant into <strong>security zones, </strong>logical groupings of assets with similar risk and protection needs, connected by <strong>conduits</strong> (controlled communication paths). This segmentation prevents a breach in one area from cascading across the entire system.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*tdHFe8VKxoYZHvYz.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1013/0*W2mhsb9cDNqdlJmY.png" /></figure><h4>Security Levels (SL 0–4): Measurable Protection</h4><p>Security Levels quantify the strength of defenses based on threat sophistication:</p><ul><li><strong>SL 1</strong>: Casual or accidental violations.</li><li><strong>SL 2</strong>: Intentional attacks with simple tools.</li><li><strong>SL 3</strong>: Sophisticated attacks with moderate resources.</li><li><strong>SL 4</strong>: Highly targeted attacks with extensive resources.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/827/0*Ew4Avm8dgKdUDEr1.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*zYTWLjGwSKybOYQk" /></figure><p>Asset owners set <strong>Target SLs</strong> via risk assessment; suppliers deliver <strong>Capability SLs</strong>; the implemented system achieves <strong>Achieved SLs</strong>.</p><h4>Seven Foundational Requirements (FRs)</h4><p>All technical controls map to these universal categories: Identification &amp; Authentication, Use Control, System Integrity, Data Confidentiality, Restricted Data Flow, Timely Response to Events, and Resource Availability.</p><h3>Real-World Benefits and Adoption</h3><p>Organizations adopting IEC 62443 report clearer roles and responsibilities, reduced attack surfaces through segmentation, and smoother audits. Certifications like ISASecure (based on 62443–4–1/4–2) give suppliers a competitive edge and help buyers verify product security.</p><p>Implementation is flexible: Start with a high-level risk assessment (62443–3–2), build your Cybersecurity Management System (CSMS per 62443–2–1), and progressively apply zones, conduits, and controls.</p><h3>Conclusion: Building a Secure Industrial Future</h3><p>IEC 62443 isn’t about adding more firewalls, it’s about embedding security into the DNA of industrial systems from design through decommissioning. In 2026 and beyond, as OT converges with IT and AI-driven automation accelerates, this standard remains the most practical path to resilient, trustworthy operations.</p><p>Whether you’re an asset owner protecting a factory floor, a supplier certifying a new PLC, or a system integrator designing tomorrow’s smart plants, IEC 62443 gives you the shared language, proven methods, and measurable outcomes needed to stay ahead of threats.</p><p>Happy reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8bf13e970d01" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/iec-62443-the-global-gold-standard-for-securing-industrial-automation-and-control-systems-8bf13e970d01">IEC 62443: The Global Gold Standard for Securing Industrial Automation and Control Systems</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The 4 Pillars of NIST SSDF: A Deep Dive into PO, PS, PW, and RV — Part 3]]></title>
            <link>https://towardsdev.com/the-4-pillars-of-nist-ssdf-a-deep-dive-into-po-ps-pw-and-rv-part-3-9485b2f5fd57?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/9485b2f5fd57</guid>
            <category><![CDATA[nist-ssdf]]></category>
            <category><![CDATA[secure-sdlc]]></category>
            <category><![CDATA[secure-software-design]]></category>
            <category><![CDATA[devsecops]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Tue, 17 Mar 2026 06:00:30 GMT</pubDate>
            <atom:updated>2026-03-17T09:34:33.270Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/532/1*vuB8XJDJ1wH_4P1VcQYmiA.png" /></figure><p>In our previous guide, we introduced NIST SP 800–218 as the “blueprint” for building secure software. But what does that blueprint actually look like?</p><p>Imagine trying to build a house without separate plans for the foundation, the framing, the electrical, and the plumbing. It would be chaos. The SSDF brings order to software security by organizing its recommendations into four distinct “practice groups,” or pillars. Each pillar represents a critical phase of the software lifecycle, from the boardroom to the incident response team.</p><p>These four pillars are:</p><ol><li>Prepare the Organization (PO)</li><li>Protect the Software (PS)</li><li>Produce Well-Secured Software (PW)</li><li>Respond to Vulnerabilities (RV)</li></ol><p>Understanding these categories is the key to unlocking the entire framework. They provide a clear roadmap for where to focus your efforts and how to build security into every layer of your organization. Let’s break down each pillar, exploring what they are, why they matter, and what specific tasks they involve.</p><h3>Pillar 1: Prepare the Organization (PO)</h3><p><strong>Focus:</strong> The “People and Process” Foundation</p><p>Before a single line of code is written, the groundwork for security must be laid at the organizational level. The “Prepare” pillar is all about ensuring that the people, processes, and technology are ready to perform secure software development. It moves security from being just a developer’s problem to a core business function.</p><p>This pillar recognizes that you cannot produce secure software if your culture, roles, and environments are not set up for it. As the saying goes, “You can’t build a secure house on a shaky foundation.”</p><p>What This Looks Like in Practice:</p><ul><li>Defining Clear Roles (PO.2): Someone must be explicitly responsible for security. This means assigning tasks like verifying code, checking for vulnerabilities, and managing access to specific people or teams. Without clear ownership, critical tasks fall through the cracks.</li><li>Establishing Secure Environments (PO.5): This is a big one. It means treating your development and build systems with the same rigor as your production environment. Key tasks include using Multi-Factor Authentication (MFA) for all developers and implementing Zero Trust principles to ensure that a compromised developer laptop cannot lead to a compromised software build. A secure product cannot come from an insecure factory.</li><li>Implementing Supporting Toolchains (PO.3): Security cannot be managed with manual checklists alone. This task encourages the use of automated tools (like static analysis scanners or dependency checkers) to improve accuracy, consistency, and efficiency. Automation helps scale security practices across multiple teams and projects.</li></ul><p><strong>Key Takeaway:</strong> The PO pillar is about answering the questions: “Do we have the right leadership, policies, and infrastructure in place to support secure development?”</p><h3>Pillar 2: Protect the Software (PS)</h3><p><strong>Focus:</strong> Integrity and Tamper-Proofing</p><p>Once the organizational foundation is set, the next pillar focuses on the software components themselves. The “Protect” pillar is all about safeguarding all forms of code, source code, executables, and configurations — from unauthorized access and tampering throughout the entire lifecycle. It addresses the threat of someone maliciously altering your software, either at rest or in transit.</p><p>This pillar is the direct response to supply chain attacks like SolarWinds, where attackers injected malicious code into a trusted software update.</p><p>What This Looks Like in Practice:</p><ul><li>Protecting Code from Unauthorized Access (PS.1): This is about basic security hygiene for your repositories. It involves strictly controlling who has read and write access to your source code, build systems, and artifact registries. A good rule of thumb is to regularly audit access lists and remove old or unnecessary permissions</li><li>Verifying Release Integrity (PS.2): How can users trust that the software they download hasn’t been tampered with? The answer is cryptographic signing. This task involves digitally signing software releases so that customers can verify the software came from you and hasn’t been altered since you signed it.</li><li>Archiving and Protecting Provenance (PS.3): You need to keep a secure, long-term record of each software release. This includes provenance data — metadata about who built the software, from what source code, and with which tools. If a vulnerability is discovered years later, this data is crucial for understanding your exposure. Version 1.1 of the SSDF added a specific task (PS.3.2) for collecting and sharing this provenance data.</li></ul><p><strong>Key Takeaway:</strong> The PS pillar is about ensuring that the software you <em>intend</em> to ship is exactly what your customers <em>receive</em>, with a verifiable chain of custody.</p><h3>Pillar 3: Produce Well-Secured Software (PW)</h3><p><strong>Focus:</strong> Building It Right from the Start</p><p>This is the largest and most detailed pillar, focusing on the nuts and bolts of development. The “Produce” pillar aims to minimize the number of vulnerabilities introduced during the design and coding phases. It’s about “building security in” rather than “bolting it on” at the end.</p><p>This pillar covers everything from secure design to rigorous testing, ensuring that the software is resilient against attacks.</p><p>What This Looks Like in Practice:</p><ul><li>Threat Modeling During Design (PW.1): Before writing code, development teams should identify potential attack vectors. This proactive exercise, known as threat modeling, helps visualize how a system might be compromised so that defenses can be built in from the start. It’s about asking, “how could this be attacked?” before it ever becomes a problem.</li><li>Reusing Well-Secured Code (PW.4): “Don’t reinvent the wheel” is a security mantra. This task encourages developers to reuse existing, well-vetted secure software components (like established cryptographic libraries) instead of writing their own, which is error prone.</li><li>Testing Executable Code (PW.8): This involves a battery of automated tests to find vulnerabilities. Specific examples from the SSDF include integrating dynamic analysis into the test suite and using fuzz testing tools to find input-handling bugs. It also recommends using Static Analysis tools to scan source code for common flaws.</li><li>Secure-by-Default Configurations (PW.9): Software should be secure out of the box. This means the most secure settings should be the default, requiring users to <em>opt-out</em> of security rather than <em>opt-in.</em> This reduces the chance of misconfiguration by end-users.</li></ul><p><strong>Key Takeaway:</strong> The PW pillar is about embedding security checks and balances into the daily workflow of every developer and tester.</p><h3>Pillar 4: Respond to Vulnerabilities (RV)</h3><p><strong>Focus:</strong> The After-Release Safety Net</p><p>No software is perfect. The “Respond” pillar acknowledges that vulnerabilities will inevitably be found <em>after</em> a product has been released. This practice group is about identifying those residual vulnerabilities, responding appropriately, and using that knowledge to prevent similar issues in the future.</p><p>A robust response capability is what separates a responsible software producer from an irresponsible one.</p><p>What This Looks Like in Practice:</p><ul><li>Identifying and Confirming Vulnerabilities (RV.1): Organizations need a process for receiving vulnerability reports from internal teams, security researchers, and customers. This includes monitoring public databases and security mailing lists to stay informed about newly discovered flaws in the components they use.</li><li>Assessing, Prioritizing, and Remediating (RV.2): Not all bugs are equal. Once a vulnerability is confirmed, teams must assess its severity, prioritize it against other work, and develop a fix or a mitigation plan. This requires a defined process for triaging and patching.</li><li>Analyzing Root Causes (RV.3): The most important step for long-term improvement. After fixing a vulnerability, teams should investigate <em>why</em> it happened. Was it a gap in training? A missing test? A flaw in the design process? By identifying the root cause, you can update your development practices to prevent the entire class of vulnerability from happening again.</li></ul><p><strong>Key Takeaway</strong>: The RV pillar is about having a plan for when (not if) something goes wrong, turning security incidents into opportunities for improvement.</p><h3>The Pillars in Action</h3><p>These four pillars are not silos; they work together. A strong PO foundation enables effective PS protections. Rigorous PW production reduces the number of issues that end up in the RV response system. And the lessons learned from RV feed back into PO to improve training and requirements.</p><p>By understanding these four pillars, you can see the SSDF for what it truly is: a holistic, lifecycle-wide approach to building software that is resilient, trustworthy, and secure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/943/1*_B8S_exxb_vdRiqymM171w.png" /></figure><p>Happy reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9485b2f5fd57" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/the-4-pillars-of-nist-ssdf-a-deep-dive-into-po-ps-pw-and-rv-part-3-9485b2f5fd57">The 4 Pillars of NIST SSDF: A Deep Dive into PO, PS, PW, and RV — Part 3</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NIST SP 800–218 Explained: A Beginner’s Guide to the Secure Software Development Framework (SSDF) —…]]></title>
            <link>https://towardsdev.com/nist-sp-800-218-explained-a-beginners-guide-to-the-secure-software-development-framework-ssdf-1f45fa4f5205?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/1f45fa4f5205</guid>
            <category><![CDATA[secure-software]]></category>
            <category><![CDATA[ssdf]]></category>
            <category><![CDATA[sdlc]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Mon, 09 Mar 2026 13:01:01 GMT</pubDate>
            <atom:updated>2026-03-10T07:21:30.753Z</atom:updated>
            <content:encoded><![CDATA[<h3>NIST SP 800–218 Explained: A Beginner’s Guide to the Secure Software Development Framework (SSDF) — Part 2</h3><figure><img alt="Secure Software Development Lifecycle (SDLC) SP 200–281" src="https://cdn-images-1.medium.com/max/855/0*-VhAplL8jmUJ4a3n.png" /></figure><p><a href="https://medium.com/towardsdev/a-simple-guide-to-building-secure-software-based-on-nist-ssdf-99b10ecdd026">NIST SSDF SP 800–218, Secure Software Development | </a>Introduction | Part 1</p><p>You’ve likely heard the headlines: “SolarWinds Hack Exposes Thousands of Companies” or “Log4j Vulnerability Sparks Global Race to Patch.”</p><p>These weren’t just random data breaches. They were systemic failures in the <em>way software is built</em>. In the wake of these attacks, the U.S. government realized that asking companies to secure their networks wasn’t enough, they needed to ensure the software <em>running</em> on those networks was trustworthy from the start.</p><p>Enter NIST Special Publication 800–218, also known as the Secure Software Development Framework (SSDF).</p><p>If you work in tech, security, or even just manage a team that builds software, you’ve probably heard this acronym thrown around. But what actually is it? Is it a law? A piece of software? A checklist?</p><p>This guide is your starting point. We are going to break down what NIST SP 800–218 is, why it suddenly matters so much, and what it aims to fix.</p><h3>The Origin Story: Why Does SSDF Exist?</h3><p>To understand the SSDF, you have to understand the problem it was designed to solve.</p><p>For decades, software security was often an afterthought. Developers focused on features and speed, while security teams tried to bolt on protections at the end, or worse, after the software was already in the hands of customers. Then came two major wake-up calls:</p><ol><li>The SolarWinds Attack (2020): Hackers infiltrated the build system of a legitimate software company (SolarWinds) and inserted malicious code into a routine software update. When customers downloaded what they thought was a trusted update, they actually installed a backdoor into their own networks. The attack exposed a massive blind spot: we trust software updates without verifying how they were made.</li><li>The Log4j Vulnerability (2021): A critical flaw was discovered in Log4j, a ubiquitous piece of open-source logging software used in millions of applications worldwide. It highlighted how deeply interconnected modern software is and how a single vulnerability in a <em>component</em> could jeopardize entire supply chains.</li></ol><p>In response, the White House issued Executive Order 14028 in May 2021, which directed NIST (the National Institute of Standards and Technology) to collaborate with industry and create a standard to improve software security. The result, published in February 2022, was NIST SP 800–218.</p><p>Think of it as the federal government’s official “blueprint” for building secure software in the modern age</p><h3>What Exactly Is NIST SP 800–218?</h3><p>At its core, the SSDF is a collection of best practices for software development. NIST took decades of industry knowledge (from groups like OWASP and SAFECode) and distilled it down into a single, organized document.</p><p>However, it is crucial to understand what kind of document it is. The SSDF is outcome-based. This means it doesn’t tell you exactly <em>how</em> to do your job (e.g., “You must use Jenkins for your builds” or “You must buy Tool X”). Instead, it defines what needs to be achieved.</p><p>For example, one task in the framework is: “Generate and obtain integrity proof artifacts for each release.”</p><ul><li><em>The “</em><strong><em>What</em></strong><em>”:</em> You need proof that your software hasn’t been tampered with.</li><li><em>The “</em><strong><em>How</em></strong><em>”:</em> You might decide to use GPG keys to sign your code or use a more modern tool like Sigstore. The choice is yours, as long as the outcome (integrity proof) is met.</li></ul><p>This flexibility is the secret sauce of the SSDF. It allows a massive government contractor and a five-person startup to use the same framework, just implemented with different tools and processes.</p><h3>What the SSDF is NOT</h3><p>To avoid confusion, it helps to clear up some common misconceptions right away:</p><ul><li>It is NOT a law (for most people). For the private sector, the SSDF is voluntary guidance. However, it becomes a <em>de facto</em> requirement if you want to sell software to the U.S. federal government.</li><li>It is NOT software. You cannot download NIST SP 800–218 and install it. It is a PDF document (available for free) that describes practices you must implement in your <em>own</em> development pipeline.</li><li>It is NOT a rigid checklist. While you can use it to create checklists, the framework itself is designed to be adapted to your specific development methodologies, whether you use Agile, Waterfall, or DevSecOps.</li></ul><h3>The “Because” Factor: Why These Practices Matter</h3><p>One of the best ways to read the SSDF is to look at the “why” behind each task. The framework isn’t just bureaucratic red tape; every recommendation closes a specific gap that attackers exploit.</p><p>Here is a preview of the logic behind the framework:</p><ul><li>We separate development environments from corporate networks (PO.5) <em>because</em> if an employee gets a phishing email, we don’t want the attacker to have a direct path into the source code of our product.</li><li>We track all external components and libraries (PS.3) <em>because</em> if a new Log4j-style vulnerability drops next week, we need to know immediately if our software uses it and where.</li><li>We review code for vulnerabilities (PW.4) <em>because</em> we want to catch the “SQL injection” flaw during development, not after a hacker has stolen customer data.</li><li>We have a process to receive vulnerability reports (RV.1) <em>because</em> even the best developers miss things; we need researchers and customers to be able to tell us about bugs safely.</li></ul><h3>Who Actually Needs to Care?</h3><p>The official documentation states the SSDF is for software producers. But who falls into that category?</p><ul><li>Commercial Software Vendors: Companies that sell software to others.</li><li>Internal IT Teams: If you build internal tools or applications for your own company, you are a producer.</li><li>Embedded Device Makers: If your hardware runs on code (cars, medical devices, IoT gadgets), that code needs to be secure.</li><li>Federal Contractors: If you want to do business with the U.S. government, aligning with SSDF is quickly becoming mandatory.</li></ul><h3>The Bottom Line</h3><p>NIST SP 800–218 isn’t just another compliance checkbox. It represents a fundamental shift in the security landscape: a move from “protect the castle” to “secure the blueprints.”</p><p>By organizing the chaos of software development into four logical pillars (Prepare, Protect, Produce, Respond), the SSDF gives organizations a roadmap. It acknowledges that software will never be perfect, but the <em>process</em> of building it must be resilient, transparent, and secure.</p><p>For beginners, the most important takeaway is this: The SSDF is the industry-wide consensus on how to build software safely. Whether you are adopting it to win government contracts or just to sleep better at night knowing your code is secure, understanding the “what” and “why” is the first step.</p><p><em>In our next article, we will dive into the Four Pillars of SSDF, breaking down the specific practice groups (PO, PS, PW, RV) and what they mean for your daily workflow.</em></p><p>Happing reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1f45fa4f5205" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/nist-sp-800-218-explained-a-beginners-guide-to-the-secure-software-development-framework-ssdf-1f45fa4f5205">NIST SP 800–218 Explained: A Beginner’s Guide to the Secure Software Development Framework (SSDF) —…</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NIST SSDF SP 800–218, Introduction to Secure Software Development]]></title>
            <link>https://towardsdev.com/a-simple-guide-to-building-secure-software-based-on-nist-ssdf-99b10ecdd026?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/99b10ecdd026</guid>
            <category><![CDATA[software-security]]></category>
            <category><![CDATA[cyber-security-awareness]]></category>
            <category><![CDATA[nist-framework]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[cloud-security]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Wed, 04 Mar 2026 06:10:43 GMT</pubDate>
            <atom:updated>2026-03-09T13:05:36.333Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="NIST SSDF SP 800–218, Secure By Design" src="https://cdn-images-1.medium.com/max/836/1*-clKrOGyp4acw5Pbv96Q1w.png" /></figure><p>Software is everywhere, banking apps, healthcare systems, fintech platforms, government portals.</p><p>But here’s the hard truth:</p><p>Most software is built to <em>work</em>… not to be <em>secure</em>.</p><p>Security is often added later, after a breach, after a penetration test, or after customers complain.</p><p>That’s where the <strong>Secure Software Development Framework (SSDF)</strong> comes in.</p><p>It’s published by the National Institute of Standards and Technology (NIST), and it gives us a practical way to build software securely from the beginning.</p><p>Officially, it’s documented as:</p><p><strong>NIST SP 800–218</strong></p><p>But don’t worry, we’ll break it down in simple terms.</p><h3>Why Do We Need Secure Software?</h3><p>Because:</p><ul><li>Attacks are increasing every year</li><li>Supply chain attacks are real</li><li>One insecure API can expose millions of records</li><li>A single leaked credential can bring down a company</li></ul><p>Security is no longer optional; it’s a core feature.</p><h3>What is the SSDF?</h3><p>The Secure Software Development Framework (SSDF) is a set of best practices that helps organizations:</p><ul><li>Build secure software</li><li>Protect their source code</li><li>Detect vulnerabilities early</li><li>Respond properly when issues are found</li></ul><p>It is not complicated or theoretical.</p><p>It focuses on practical outcomes.</p><h3>The 4 Main Areas of SSDF (In Simple Words)</h3><p>SSDF is organized into four major areas:</p><ol><li>Prepare</li><li>Protect</li><li>Produce Secure Software</li><li>Respond to Problems</li></ol><p>Let’s go through them one by one.</p><h3>1️. Prepare the Organization (PO)</h3><p>Before writing secure code, the organization must be ready.</p><p>This includes:</p><ul><li>Defining security requirements</li><li>Training developers in secure coding</li><li>Assigning clear security roles</li><li>Choosing proper security tools</li></ul><p>If developers are not trained, and no one owns security — problems are guaranteed.</p><p>Security must be part of the culture.</p><h3>2️. Protect the Software (PS)</h3><p>This means protecting:</p><ul><li>Source code repositories</li><li>Build pipelines</li><li>Dependencies</li><li>Secrets and credentials</li></ul><p>Examples:</p><ul><li>Enforce multi-factor authentication for Git access</li><li>Scan dependencies for known vulnerabilities</li><li>Lock down CI/CD pipelines</li><li>Sign software artifacts before release</li></ul><p>If attackers can modify your source code or pipeline, your entire product is compromised.</p><h3>3️. Produce Well-Secured Software (PW)</h3><p>This is where developers play the biggest role.</p><p>Key practices include:</p><h3>Threat Modeling</h3><p>Before building features, ask:</p><ul><li>What could go wrong?</li><li>How could someone abuse this feature?</li><li>What data are we exposing?</li></ul><h3>Secure Coding</h3><ul><li>Validate all input</li><li>Encode all output</li><li>Avoid hardcoded secrets</li><li>Use strong authentication and authorization</li></ul><h3>Security Testing</h3><ul><li>Static code analysis (SAST)</li><li>Dynamic testing (DAST)</li><li>Dependency scanning</li><li>Code reviews</li></ul><p>The earlier you find vulnerabilities, the cheaper they are to fix.</p><h3>4️. Respond to Vulnerabilities (RV)</h3><p>Even secure software can have vulnerabilities.</p><p>What matters is how fast and how professionally you respond.</p><p>You need:</p><ul><li>A vulnerability disclosure process</li><li>Clear patch management procedures</li><li>Root cause analysis</li><li>Continuous improvement</li></ul><p>Security is not “one and done.” It’s ongoing.</p><h3>How SSDF Fits into Modern DevOps</h3><p>SSDF works perfectly with DevOps and CI/CD.</p><p>Instead of doing security at the end, you integrate it into:</p><ul><li>Planning</li><li>Design</li><li>Development</li><li>Testing</li><li>Deployment</li><li>Operations</li></ul><p>This approach is often called <strong>DevSecOps</strong>.</p><p>Security becomes automated and continuous.</p><h3>Why This Matters for Developers</h3><p>Many developers think:</p><p>“Security is the security team’s job.”</p><p>That mindset is outdated.</p><p>Today:</p><ul><li>Developers write secure code</li><li>Architects design secure systems</li><li>DevOps engineers secure pipelines</li><li>Security teams guide and verify</li></ul><p>Security is everyone’s responsibility.</p><h3>Real-World Example</h3><p>Imagine you are building a banking API.</p><p>Without SSDF:</p><ul><li>You build fast</li><li>You deploy</li><li>Later you discover weak authentication</li><li>Emergency patching begins</li></ul><p>With SSDF:</p><ul><li>Security requirements are defined first</li><li>Threat modeling identifies abuse cases</li><li>Automated scans catch vulnerabilities early</li><li>Deployment includes signed artifacts</li><li>Monitoring detects suspicious activity</li></ul><p>The difference is proactive vs reactive security.</p><h3>Final Thoughts</h3><p>The Secure Software Development Framework is not about adding more bureaucracy.</p><p>It’s about:</p><ul><li>Thinking about security early</li><li>Automating security checks</li><li>Reducing risk</li><li>Protecting customers</li><li>Protecting your company’s reputation</li></ul><p>In simple terms:</p><blockquote><em>Build software securely from day one — not after something goes wrong.</em></blockquote><p>If you’re a developer, architect, or engineering leader, learning and applying SSDF principles can significantly improve your software quality and resilience.</p><p>Security is not just a requirement.</p><p>It’s a responsibility.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=99b10ecdd026" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/a-simple-guide-to-building-secure-software-based-on-nist-ssdf-99b10ecdd026">NIST SSDF SP 800–218, Introduction to Secure Software Development</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding RHEL OpenShift Architecture: A Modern Cloud-Native Platform]]></title>
            <link>https://medium.com/@Sade_Shure/understanding-rhel-openshift-architecture-a-modern-cloud-native-platform-af3c8c210c2e?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/af3c8c210c2e</guid>
            <category><![CDATA[openshift]]></category>
            <category><![CDATA[kubernetes]]></category>
            <category><![CDATA[containers]]></category>
            <category><![CDATA[red-hat-openshift]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Mon, 29 Sep 2025 12:24:06 GMT</pubDate>
            <atom:updated>2025-09-29T13:01:46.715Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*8nZ4MFITlm0ApnEn.jpg" /></figure><p>Red Hat OpenShift is one of the leading <strong>enterprise Kubernetes platforms</strong>, providing developers and IT teams a robust environment to build, deploy, and manage containerized applications. Understanding its architecture is key to leveraging its full potential.</p><h4>The Foundation: Kubernetes as the Engine</h4><p>Imagine Kubernetes as the powerful engine of a high-performance car. It handles the core orchestration tasks:</p><ul><li>Scheduling: Deciding which worker node should run a containerized application.</li><li>Networking: Managing how pods (the smallest deployable units in Kubernetes) communicate with each other and the outside world.</li><li>Self-Healing: Automatically restarting failed containers and rescheduling pods if a node goes down.</li><li>Service Discovery &amp; Load Balancing: Ensuring traffic is efficiently distributed across multiple instances of an application.</li></ul><p>OpenShift doesn’t replace this engine; it builds a complete, safe, and user-friendly vehicle around it.</p><h3>The Architectural Layers of OpenShift</h3><p>The OpenShift architecture can be visualized in distinct, integrated layers, each responsible for a critical part of the platform’s functionality.</p><h4>Layer 1: The Operating System — Red Hat Enterprise Linux (RHEL) or RHEL CoreOS</h4><p>Every great platform needs a solid foundation. OpenShift runs on Red Hat Enterprise Linux (RHEL) or, more commonly in modern automated deployments, RHEL CoreOS.</p><ul><li>RHEL CoreOS: This is a lightweight, immutable, and container-optimized operating system. Its “immutable” nature means the OS is updated as a whole unit via an atomic update process, dramatically enhancing security and consistency. You don’t manually patch packages; you replace the entire OS image, ensuring all nodes in your cluster are identical.</li></ul><h4>Layer 2: The Container Runtime: CRI-O</h4><p>While Docker popularized containers, OpenShift uses CRI-O, a lightweight, open-source container runtime strictly designed for Kubernetes. It implements the Kubernetes Container Runtime Interface (CRI) and is purpose-built for stability and performance in production Kubernetes environments. It pulls container images from registries like Red Hat Quay and runs them as pods.</p><h4>Layer 3: The Orchestration Core: Kubernetes</h4><p>This is the standard upstream Kubernetes distribution, which OpenShift meticulously tests, hardens, and supports. It includes all the core components you’d expect:</p><ul><li>API Server: The front-end for the entire control plane.</li><li>etcd: A distributed key-value store that acts as the “single source of truth” for the cluster state.</li><li>Scheduler &amp; Controller Manager: The brains behind scheduling and maintaining the desired state.</li><li>Kubelet: The agent that runs on each node and ensures containers are running in pods.</li></ul><h4>Layer 4: The OpenShift Value-Add (The “Magic Sauce”)</h4><p>This is where OpenShift truly differentiates itself from a DIY Kubernetes setup. It wraps the core Kubernetes engine with enterprise-critical features.</p><p>1. Enhanced Developer Experience:</p><ul><li>Source-to-Image (S2I): A revolutionary tool that allows developers to simply provide application source code. OpenShift automatically detects the language (e.g., Java, Python, Node.js), builds a container image from it, and deploys it. This streamlines CI/CD and enforces best practices.</li><li>Web Console (UI): An intuitive graphical interface that provides developers and operators with a clear view of applications, builds, deployments, and metrics, reducing the learning curve of the Kubernetes CLI.</li><li>oc CLI: The OpenShift command-line tool, which is a powerful superset of kubectl, offering additional commands for builds, deployments, and project management.</li></ul><p>2. Robust Networking (SDN — Software-Defined Networking):<br>OpenShift ships with a highly scalable and secure networking solution out-of-the-box.</p><ul><li>OpenShift SDN: The default plugin, providing a full network cluster where every pod can communicate with every other pod.</li><li>OVN-Kubernetes: A more advanced option offering enhanced network policies, better performance, and support for virtualized workloads.</li></ul><p>3. Integrated Registry &amp; Image Management:<br>Every OpenShift cluster includes a built-in, private container registry. This allows for fast, secure image builds and deployments without relying on external networks. For enterprise-wide scale, it integrates seamlessly with Red Hat Quay, a more advanced container registry.</p><p>4. Stateful Application Support with Persistent Storage:<br>OpenShift abstracts complex storage backends through Persistent Volumes (PVs) and Persistent Volume Claims (PVCs). It features deep integrations with a wide array of storage providers (e.g., AWS EBS, Azure Disk, Google Persistent Disk, NFS, Ceph, and more), making it simple to run stateful applications like databases.</p><p>5. Enterprise-Grade Security by Default:<br>Security isn’t an afterthought; it’s woven into the fabric of OpenShift.</p><ul><li>Security-Enhanced Linux (SELinux): Enforced by the underlying RHEL OS for mandatory access controls.</li><li>Role-Based Access Control (RBAC): Fine-grained control over who can do what within the cluster.</li><li>Pod Security Policies / Security Context Constraints (SCCs): A powerful OpenShift feature that controls the actions a pod can perform, limiting its capabilities to the minimum required (e.g., preventing a container from running as root).</li><li>Automated TLS Certificate Management: Integrated with Let’s Encrypt for easy and secure HTTPS endpoints.</li></ul><p>6. Built-in Monitoring and Logging:<br>OpenShift includes Prometheus and Grafana for comprehensive cluster and application monitoring right out of the box. It also integrates with the EFK Stack (Elasticsearch, Fluentd, Kibana) for centralized logging, providing deep insights into application and system behavior.</p><h4>Visualizing the Cluster: Master, Worker, and Infrastructure Nodes</h4><p>An OpenShift cluster is a set of nodes (physical or virtual machines) grouped into logical roles:</p><ul><li>Control Plane Nodes (Masters): These nodes host the core Kubernetes and OpenShift control plane components (API Server, etcd, Scheduler). For high availability, a production cluster typically has three or more master nodes.</li><li>Worker Nodes: These are the workhorses where your application containers (pods) actually run. They are managed by the control plane.</li><li>Infrastructure Nodes: In many deployments, certain worker nodes are designated to run critical cluster services like the router (ingress), integrated registry, and monitoring components, isolating them from user applications.</li></ul><p><strong>OpenShift Deployment Models</strong></p><p>OpenShift can be deployed in multiple ways:</p><ol><li><strong>Self-Managed OpenShift</strong> (IPI/UPI)</li></ol><ul><li>Full control over master and worker nodes</li><li>Suitable for private data centers or cloud VMs</li></ul><p><strong>2. Managed OpenShift</strong> (ROSA, OpenShift Dedicated)</p><ul><li>Control plane managed by cloud provider or Red Hat</li><li>Users manage only worker nodes and applications</li></ul><p><strong>3. Single Node OpenShift / CodeReady Containers</strong></p><ul><li>Loca development and testing environment</li><li>Minimal footprint, simulates a full cluster</li></ul><h3>Conclusion</h3><p>OpenShift architecture is a <strong>layered, enterprise-ready Kubernetes platform</strong>. By combining Kubernetes core functionality with OpenShift platform services, security, and automation, it provides a <strong>robust environment for deploying cloud-native applications at scale</strong>.</p><p>A good understanding of these layers helps administrators, developers, and architects <strong>optimize deployments, troubleshoot effectively, and maintain secure and highly available clusters</strong>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=af3c8c210c2e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding the JavaScript Event Loop: How Asynchronous Magic Happens]]></title>
            <link>https://towardsdev.com/understanding-the-javascript-event-loop-how-asynchronous-magic-happens-921c40454f1d?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/921c40454f1d</guid>
            <category><![CDATA[event-loop]]></category>
            <category><![CDATA[advanced-javascript]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[nodejs-event-loop]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Wed, 21 May 2025 08:32:34 GMT</pubDate>
            <atom:updated>2025-05-21T15:28:51.244Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/317/1*XgPQ-mmRy7PM6O6uMundKw.jpeg" /></figure><h3>Introduction</h3><p>JavaScript is a single-threaded language, meaning it can only execute one task at a time. Yet, it handles asynchronous operations like API calls, timers, and user interactions seamlessly. The secret behind this non-blocking behavior is the <strong>event loop</strong>, a core component of JavaScript’s runtime environment. This article dives into how the event loop works, its components, and why it’s crucial for building responsive applications.</p><h3>What is the Event Loop?</h3><p>The event loop is a mechanism that manages the execution of code in JavaScript, ensuring that asynchronous tasks (like setTimeout, promises, or event handlers) are processed efficiently without blocking the main thread. It coordinates the <strong>call stack</strong>, <strong>task queue</strong>, and <strong>microtask queue</strong> to prioritize and execute tasks in the correct order.</p><h3>Key Components</h3><ol><li><strong>Call Stack</strong></li></ol><ul><li>A stack data structure that tracks function execution in a Last-In-First-Out (LIFO) order.</li><li>Synchronous code is pushed onto the stack, executed, and popped off when complete.</li><li>If the stack is empty, the event loop can process queued tasks.</li></ul><p><strong>2. Task Queue</strong> (aka Macrotask Queue)/ Web/Browser API</p><ul><li>Holds asynchronous tasks like setTimeout, setInterval, DOM events, or AJAX callbacks.</li><li>Tasks are processed only when the call stack is empty.</li></ul><p>3. <strong>Microtask Queue</strong></p><ul><li>A higher-priority queue for tasks like promise resolutions (then, catch) and queueMicrotask.</li><li>Microtasks are executed before tasks in the task queue, even if added later.</li></ul><p>4. <strong>Event Loop</strong></p><ul><li>Continuously monitors the call stack and queues.</li><li>When the call stack is empty, it first processes all microtasks, then moves to the task queue to enqueue the next task.</li></ul><h3>How It Works</h3><p>The event loop follows a simple cycle:</p><ol><li>Check if the <strong>call stack</strong> is empty.</li><li>If empty, process all tasks in the <strong>microtask queue</strong> until it’s empty.</li><li>Take the next task from the <strong>task queue</strong> and push it onto the call stack.</li><li>Repeat the cycle.</li></ol><p>This ensures that synchronous code runs immediately, microtasks (like promises) are prioritized, and other asynchronous tasks (like timers) are handled in order.</p><h3>Example</h3><p>Here’s a practical example to illustrate the event loop in action:</p><pre>console.log(&quot;Start&quot;);<br><br>setTimeout(() =&gt; console.log(&quot;Timeout&quot;), 0);<br><br>Promise.resolve().then(() =&gt; console.log(&quot;Promise&quot;));<br><br>console.log(&quot;End&quot;);</pre><p><strong>Output</strong></p><pre>Start<br>End<br>Promise<br>Timeout</pre><p><strong>Explanation</strong>:</p><ul><li><strong>Synchronous Code</strong>: console.log(“Start”) and console.log(“End”) are executed immediately on the call stack.</li><li><strong>Promise</strong>: The .then callback is added to the microtask queue. When the call stack is empty, the event loop processes it, logging “Promise”.</li><li><strong>setTimeout</strong>: The callback is added to the task queue. It runs only after the microtask queue is empty, logging “Timeout”.</li></ul><h3>Why It Matters</h3><p>The event loop is what makes JavaScript feel fast and responsive:</p><ul><li><strong>Non-Blocking I/O</strong>: Long-running tasks like network requests don’t freeze the application.</li><li><strong>User Experience</strong>: Event handlers (e.g., clicks, keypresses) are processed promptly.</li><li><strong>Efficient Resource Use</strong>: The single-threaded model avoids the complexity of multithreading.</li></ul><p>However, developers must be cautious:</p><ul><li><strong>Blocking the Call Stack</strong>: Heavy synchronous computations can delay task processing, making the UI unresponsive.</li><li><strong>Microtask Overload</strong>: Excessive promise chaining can starve the task queue, delaying timers or events.</li></ul><h3>Practical Tips</h3><ol><li><strong>Use Promises and Async/Await</strong>: They leverage the microtask queue for cleaner asynchronous code.</li><li><strong>Avoid Long-Running Tasks</strong>: Break heavy computations into smaller chunks using setTimeout or requestAnimationFrame.</li><li><strong>Monitor Performance</strong>: Use browser dev tools to inspect the call stack and task queues for bottlenecks.</li></ol><h3>More Examples: From Simple to Advanced</h3><p>To deepen your understanding, here are five additional examples showcasing the event loop in various scenarios, progressing from simple to advanced. Do each examples by yourself and test your knowledge.</p><h3>Example 1: Basic Synchronous vs. Asynchronous</h3><pre>console.log(&quot;First&quot;);<br>setTimeout(() =&gt; console.log(&quot;Second&quot;), 1000);<br>console.log(&quot;Third&quot;);</pre><p><strong>Output</strong></p><pre>Start<br>End<br>Promise 1<br>Promise 2<br>Timeout 1<br>Timeout 2</pre><p><strong>Explanation</strong>: “First” and “Third” execute synchronously on the call stack. The setTimeout callback is added to the task queue and runs after the 1-second delay, once the call stack is empty.</p><h3>Example 2: Mixing Promises and Timers</h3><pre>console.log(&quot;Start&quot;);<br>setTimeout(() =&gt; console.log(&quot;Timeout 1&quot;), 0);<br>Promise.resolve()<br>  .then(() =&gt; console.log(&quot;Promise 1&quot;))<br>  .then(() =&gt; console.log(&quot;Promise 2&quot;));<br>setTimeout(() =&gt; console.log(&quot;Timeout 2&quot;), 0);<br>console.log(&quot;End&quot;);</pre><p><strong>Output</strong></p><pre>Start<br>End<br>Promise 1<br>Promise 2<br>Timeout 1<br>Timeout 2</pre><p><strong>Explanation</strong>: Synchronous code (“Start”, “End”) runs first. The chained .then callbacks are added to the microtask queue and executed before the task queue’s setTimeout callbacks, demonstrating microtask priority.</p><h3>Example 3: Event Listener with Microtasks</h3><pre>document.querySelector(&quot;button&quot;).addEventListener(&quot;click&quot;, () =&gt; {<br>  console.log(&quot;Button clicked&quot;);<br>  Promise.resolve().then(() =&gt; console.log(&quot;Microtask after click&quot;));<br>});<br>console.log(&quot;Script start&quot;);</pre><p><strong>Output</strong> (on button click)</p><pre>Script start<br>Button clicked<br>Microtask after click</pre><p><strong>Explanation</strong>: “Script start” runs synchronously. When the button is clicked, the event listener’s callback is added to the task queue. Upon execution, it logs “Button clicked” and queues a microtask, which runs immediately after due to its higher priority.</p><h3>Example 4: Heavy Computation Blocking the Event Loop</h3><pre>console.log(&quot;Start&quot;);<br>setTimeout(() =&gt; console.log(&quot;Timeout&quot;), 0);<br>function heavyComputation() {<br>  let sum = 0;<br>  for (let i = 0; i &lt; 1e9; i++) sum += i;<br>  return sum;<br>}<br>console.log(heavyComputation());<br>console.log(&quot;End&quot;);</pre><p><strong>Output</strong></p><pre>Start<br>(After delay due to computation)<br>End<br>Timeout</pre><p><strong>Explanation</strong>: The heavyComputation blocks the call stack, delaying the event loop from processing the setTimeout callback in the task queue until the computation completes. This highlights the importance of avoiding blocking code.</p><h3>Example 5: Async/Await with Multiple Promises</h3><pre>async function fetchData() {<br>  console.log(&quot;Fetch start&quot;);<br>  await new Promise(resolve =&gt; setTimeout(() =&gt; resolve(&quot;Data 1&quot;), 1000));<br>  console.log(&quot;Data 1 received&quot;);<br>  await new Promise(resolve =&gt; setTimeout(() =&gt; resolve(&quot;Data 2&quot;), 500));<br>  console.log(&quot;Data 2 received&quot;);<br>}<br>fetchData();<br>console.log(&quot;Script running&quot;);<br>setTimeout(() =&gt; console.log(&quot;Timeout&quot;), 0);</pre><p><strong>Output</strong></p><pre>Fetch start<br>Script running<br>Timeout<br>(After ~1s)<br>Data 1 received<br>(After ~0.5s)<br>Data 2 received</pre><p><strong>Explanation</strong>: fetchData runs synchronously until the first await, which pauses execution and schedules the promise resolution in the microtask queue after the timer. “Script running” and the setTimeout callback run first (task queue), then the microtasks from await resolve, showing how async/await integrates with the event loop.</p><h3>Conclusion</h3><p>The JavaScript event loop is the backbone of its asynchronous capabilities, enabling efficient handling of tasks in a single-threaded environment. By understanding the interplay between the call stack, microtask queue, and task queue, developers can write more performant and responsive applications. Next time you use a setTimeout or a promise, remember: the event loop is quietly ensuring everything runs smoothly.</p><p>Happy learning! Happing Coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=921c40454f1d" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/understanding-the-javascript-event-loop-how-asynchronous-magic-happens-921c40454f1d">Understanding the JavaScript Event Loop: How Asynchronous Magic Happens</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mastering Mobile-First Responsive Design in React Native]]></title>
            <link>https://towardsdev.com/mastering-mobile-first-responsive-design-in-react-native-46f0e25ac6bb?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/46f0e25ac6bb</guid>
            <category><![CDATA[react]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[react-native]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Tue, 17 Dec 2024 19:19:52 GMT</pubDate>
            <atom:updated>2024-12-18T16:47:38.320Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/480/0*G2rYr0w2pBdksKl4.jpg" /></figure><p>Responsive design is essential for modern mobile applications. As a <strong>React Native developer</strong>, creating mobile-first responsive layouts that work across various devices and screen sizes is critical. In this article, I’ll walk through key techniques to help you achieve responsive designs and optimize your React Native apps for mobile-first use cases.</p><h3>What is Mobile-First Design?</h3><p>Mobile-first design means designing your app to work optimally on smaller screens (mobile devices) first, then scaling it up for larger devices like tablets and desktops. This approach focuses on <strong>user experience</strong> by considering mobile as the baseline, providing a better overall experience, especially on mobile platforms.</p><p>React Native, a powerful framework for mobile development, allows you to leverage multiple techniques to create responsive layouts for mobile devices, ensuring your app adapts smoothly across different screen sizes.</p><h3>Key Techniques for Responsive Design in React Native</h3><h4>1. Using Flexbox for Layouts</h4><p>Flexbox is a layout model that allows you to build flexible and responsive layouts. It’s the go-to layout system in React Native and is designed to distribute space dynamically and align content inside containers.</p><ul><li><strong>flexDirection</strong>: Specifies the direction of the flex container’s children (either row (default)or column).</li><li><strong>alignItems</strong>: Aligns items on the cross-axis (vertically when the flex direction is row).</li><li><strong>justifyContent</strong>: Aligns items on the main axis (horizontally for row layout).</li></ul><p><strong>Example:</strong></p><pre>const styles = StyleSheet.create({<br>  container: {<br>    flex: 1,<br>    flexDirection: &#39;column&#39;, // Vertical layout<br>    justifyContent: &#39;center&#39;, // Align content center<br>    alignItems: &#39;center&#39;, // Align items to the center<br>  },<br>});</pre><h4>2. Using Percentage-based Width/Height</h4><p>To make your components responsive, use percentage-based values for width and height. This ensures components scale based on the device’s screen size.</p><p><strong>Example:</strong></p><pre>const styles = StyleSheet.create({<br>  card: {<br>    width: &#39;80%&#39;,  // Takes 80% of the screen width<br>    height: &#39;50%&#39;, // Takes 50% of the screen height<br>  },<br>});</pre><h4>3. The Dimensions API</h4><p>React Native provides the Dimensions API to get the current screen’s width and height. This is useful for dynamically adjusting layout based on the screen size.</p><p><strong>Example:</strong></p><pre>import { Dimensions } from &#39;react-native&#39;;<br><br>const { width, height } = Dimensions.get(&#39;window&#39;); // Get device screen width and height<br><br>const styles = StyleSheet.create({<br>  container: {<br>    width: width * 0.8,  // 80% of screen width<br>    height: height * 0.5, // 50% of screen height<br>  },<br>});</pre><h4>4. Media Queries with react-native-responsive-screen</h4><p>Media queries help you apply different styles based on device properties like screen size. You can use the react-native-responsive-screen library to easily handle responsive screen sizes.</p><p><strong>Installation:</strong></p><pre>npm install react-native-responsive-screen</pre><p>Usage Example:</p><pre>import { responsiveWidth, responsiveHeight } from &#39;react-native-responsive-screen&#39;;<br><br>const styles = StyleSheet.create({<br>  container: {<br>    width: responsiveWidth(80),  // 80% of screen width<br>    height: responsiveHeight(40), // 40% of screen height<br>  },<br>});</pre><h4>5. Responsive Fonts</h4><p>Using fixed font sizes can lead to a poor experience on different screen sizes. To achieve better scalability, use the react-native-responsive-fontsize library to adjust font sizes dynamically.</p><p><strong>Installation:</strong></p><pre>npm install react-native-responsive-fontsize</pre><p>Usage Example:</p><pre>import { RFValue } from &#39;react-native-responsive-fontsize&#39;;<br><br>const styles = StyleSheet.create({<br>  title: {<br>    fontSize: RFValue(18), // Scalable font size based on screen size<br>  },<br>});</pre><h4>6. Handling Platform-Specific Design</h4><p>React Native allows you to differentiate styles based on the platform (iOS vs Android). You can use the Platform module to apply platform-specific styles.</p><p><strong>Example:</strong></p><pre>import { Platform } from &#39;react-native&#39;;<br><br>const styles = StyleSheet.create({<br>  container: {<br>    backgroundColor: Platform.OS === &#39;ios&#39; ? &#39;lightblue&#39; : &#39;lightgreen&#39;,<br>  },<br>});</pre><h4>7. Handling Orientation Changes</h4><p>It’s important to handle orientation changes (portrait to landscape) for a better experience on mobile devices. You can detect orientation changes using the Dimensions API and adjust your layout accordingly.</p><p><strong>Example:</strong></p><pre>import React, { useState, useEffect } from &#39;react&#39;;<br>import { Dimensions, View, Text } from &#39;react-native&#39;;<br><br>const MyComponent = () =&gt; {<br>  const [orientation, setOrientation] = useState(&#39;portrait&#39;);<br><br>  useEffect(() =&gt; {<br>    const updateOrientation = () =&gt; {<br>      const { width, height } = Dimensions.get(&#39;window&#39;);<br>      if (width &gt; height) {<br>        setOrientation(&#39;landscape&#39;);<br>      } else {<br>        setOrientation(&#39;portrait&#39;);<br>      }<br>    };<br><br>    Dimensions.addEventListener(&#39;change&#39;, updateOrientation);<br><br>    return () =&gt; {<br>      Dimensions.removeEventListener(&#39;change&#39;, updateOrientation);<br>    };<br>  }, []);<br><br>  return (<br>    &lt;View&gt;<br>      &lt;Text&gt;{`Current Orientation: ${orientation}`}&lt;/Text&gt;<br>    &lt;/View&gt;<br>  );<br>};</pre><h4>8. Use SafeAreaView for iPhone Notches</h4><p>For devices like iPhone X and newer with notches, use <strong>SafeAreaView</strong> to prevent content from being hidden by the notch or the interactive areas (like the home indicator).</p><p><strong>Example:</strong></p><pre>import { SafeAreaView } from &#39;react-native&#39;;<br><br>const MyScreen = () =&gt; {<br>  return (<br>    &lt;SafeAreaView style={{ flex: 1 }}&gt;<br>      {/* Your content goes here */}<br>    &lt;/SafeAreaView&gt;<br>  );<br>};</pre><h4>9. Testing Across Multiple Devices</h4><p>Testing your app on different devices and simulators ensures your layout behaves as expected. Use <strong>emulators</strong> or <strong>real devices</strong> to check how your app adapts across various screen sizes and resolutions.</p><ul><li><strong>Use Emulators</strong>: Simulators for iOS and Android help test across multiple devices.</li><li><strong>Test on Real Devices</strong>: Real-world testing often uncovers problems that emulators cannot simulate.</li></ul><h3>Conclusion</h3><p>Responsive design is key to building an app that looks great and performs well across all devices. By combining <strong>Flexbox</strong>, <strong>percentage-based layouts</strong>, <strong>Dimensions</strong>, <strong>media queries</strong>, and other React Native techniques, you can create scalable, flexible, and responsive mobile applications that deliver a seamless user experience on different screen sizes.</p><p>For React Native developers, mastering these concepts will significantly improve your skills, making you a better frontend engineer capable of building user-friendly, mobile-first applications.</p><p>Happy reading!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46f0e25ac6bb" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/mastering-mobile-first-responsive-design-in-react-native-46f0e25ac6bb">Mastering Mobile-First Responsive Design in React Native</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AWS Global Infrastructure]]></title>
            <link>https://medium.com/@Sade_Shure/aws-global-infrastructure-4f8aa31a1d51?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f8aa31a1d51</guid>
            <category><![CDATA[aws-ec2]]></category>
            <category><![CDATA[aws]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Thu, 15 Feb 2024 09:20:35 GMT</pubDate>
            <atom:updated>2024-02-15T09:25:39.326Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/1*Rr-jKIK87yh2K3PExCnrJw.png" /></figure><p>Amazon Web Services (AWS) is like a giant toolbox for building and running applications in the cloud. But have you ever wondered how AWS makes sure everything works smoothly, no matter where you are in the world? Let’s take a journey into the AWS global infrastructure to uncover the magic behind its global reach and reliability.</p><p>In the world of technology, the term <strong>global infrastructure</strong> might sound a bit complex, but when it comes to Amazon Web Services (AWS), it’s the backbone of how they provide their cloud services around the globe. In this article, we’ll break down AWS’s global infrastructure using simple words to help you understand how it all works.</p><p><strong>What is AWS Global Infrastructure?</strong></p><p>Think of AWS as a vast network of data centers spread across the globe. These data centers are like big, secure warehouses full of computers that store and process your digital workloads. AWS has these data centers in different regions worldwide to get your data closer to you, making things faster and more reliable.</p><p>Key components of AWS Global Infrastructure</p><p>The AWS Global Infrastructure is a comprehensive network of data centers, edge locations, and network infrastructure designed to provide scalable and reliable cloud services. Here are key components of AWS Global Infrastructure.</p><p>1. <strong>AWS Regions</strong></p><ul><li><strong>Definition:</strong>- Geographical locations around the world where AWS has a cluster of data centers.</li><li>Purpose: Provides customers with the ability to choose the geographic location of their resources based on factors such as data residency and compliance requirements.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gVmlwIFEH4_C1BWY" /></figure><p>2.<strong> Availability Zones (AZs)</strong></p><ul><li>Definition: Isolated data centers<strong> within</strong> a region, each with its own power, cooling, and networking infrastructure.</li><li>Purpose: Offers fault tolerance and high availability by ensuring that if one Availability Zone goes down, others can continue to operate independently.</li><li>Typically, each region has multiple Availability Zones (at least 2 or more).</li></ul><p>3. <strong>Edge Locations:</strong></p><ul><li>Definition: Small data centers or points of presence located in various cities around the world.</li><li>Purpose: Optimizes content delivery and reduces latency for end-users by caching frequently accessed content, such as images, videos, and websites.</li></ul><p>4.<strong> Direct Connect</strong></p><ul><li>Definition: A dedicated network connection from on-premises data centers to AWS.</li><li>Purpose: Offers a private and dedicated connection, reducing latency and providing more consistent network performance compared to internet-based connections.</li></ul><p><strong>5. Content Delivery Network (Amazon CloudFront)</strong></p><ul><li>Definition: A global content delivery service that securely delivers data, videos, applications, and APIs to customers.</li><li>Purpose: Improves the performance and scalability of websites and applications by caching content at edge locations.</li></ul><p><strong>6. Global Accelerator</strong></p><ul><li>Definition: A service that uses static IP addresses and Anycast routing to route traffic over the AWS global network.</li><li>Purpose: Provides improved availability and performance by directing traffic over the optimal AWS network path.</li></ul><p><strong>7. AWS Wavelength</strong></p><ul><li>Definition: A service that brings AWS compute and storage services to the edge of the 5G network.</li><li>Purpose: Enables ultra-low latency applications by placing compute resources closer to mobile and connected devices.</li></ul><p><strong>8. AWS Transit Gateway</strong></p><ul><li>Definition: A service that simplifies network connectivity and routing across multiple Amazon VPCs (Virtual Private Clouds) and on-premises networks.</li><li>Purpose: Streamlines network architecture, making it easier to scale and manage connectivity within complex network infrastructures.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f8aa31a1d51" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Oracle Database 19c: Backup and Recovery — Part I]]></title>
            <link>https://towardsdev.com/oracle-database-19c-backup-and-recovery-part-i-b2b45606a882?source=rss-3fb49f1e0513------2</link>
            <guid isPermaLink="false">https://medium.com/p/b2b45606a882</guid>
            <category><![CDATA[oracle-database]]></category>
            <category><![CDATA[oracle]]></category>
            <category><![CDATA[backup-and-restore]]></category>
            <category><![CDATA[rman]]></category>
            <category><![CDATA[oracle-cloud]]></category>
            <dc:creator><![CDATA[Sade Shure Garmamo]]></dc:creator>
            <pubDate>Mon, 05 Feb 2024 14:31:29 GMT</pubDate>
            <atom:updated>2024-02-05T16:15:23.036Z</atom:updated>
            <content:encoded><![CDATA[<h3>Oracle Database 19c: Backup and Recovery — Part I</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oLlk2At1sXPAzHAgndQqpQ.jpeg" /></figure><p><strong>Introduction to Oracle 19c Backup and recovery</strong></p><p>In today’s ever-changing data management environment, ensuring the security and accessibility of vital information is of utmost importance. For businesses that depend on Oracle Database systems, the efficient and reliable backup and restoration of data is not only a recommended approach but a critical strategic necessity.</p><p>In this comprehensive guide, we delve into the intricacies of Oracle Database backups, exploring two fundamental tools at the heart of data protection: Data Pump and Recovery Manager (RMAN). Through a combination of logical and physical backup methodologies, Oracle administrators can fortify their data assets against potential disasters, minimize downtime, and ensure business continuity.</p><p>Oracle Data Pump, with its versatile export (expdp) and import (impdp) utilities, empowers users to perform logical backups, facilitating the seamless transfer of data between databases and environments. Meanwhile, Recovery Manager (RMAN) offers a robust framework for physical backups, enabling the creation of full database snapshots and incremental backups to safeguard against hardware failures, corruptions, or catastrophic events.</p><p>In summary, Oracle provides two main tools for taking backups: Data Pump (expdp/impdp) for <strong>logical backups</strong> and Recovery Manager (RMAN) for <strong>physical backups. </strong>Let us understand the Data Pump in this section.</p><h3>Understanding Data Pump (expdp/impdp):</h3><h3>What is Oracle Data Pump?</h3><p><strong>Oracle Data Pump</strong> is a feature in Oracle Database that provides high-speed data and metadata movement between Oracle databases. It offers a set of utilities that enable efficient data import, export, and migration operations.</p><p>Oracle Data Pump has two main components, The<strong> Data Pump Export utility (expdp) </strong>and the <strong>Data Pump Import utility (impdp</strong>).</p><p>The Data Pump Export utility allows you to extract data and metadata from a source database into a dump file set. This dump file set contains a logical representation of the source database objects, such as tables, indexes, and stored procedures. You can use various options and filters to control which objects are exported and how the data is exported.</p><p>The Data Pump Import utility allows you to load the data and metadata contained in a dump file set into a target database. It provides options to control how the data is imported, such as specifying the location of the dump files, choosing which objects to import, and transforming the data during the import process.</p><p>Oracle Data Pump offers several advantages over the traditional Oracle Export and Import utilities. It provides improved performance through parallel processing, network-based data movement, and compression. It also offers enhanced security features, such as encryption and password protection for the dump files.</p><p>Overall, Oracle Data Pump is a powerful tool that simplifies the process of moving data between Oracle databases, making it an essential component for data migration, backup and recovery, and other data management tasks.</p><p><strong>The Data Pump Export utility (expdp)</strong></p><p>Let us begin taking backups using a data pump and play with real production databases. Here is the syntax of expdp with <strong>minimum</strong> required parameters.</p><pre>expdp username/password@connect_string DIRECTORY=directory_object DUMPFILE=dumpfile_name.dmp LOGFILE=log_file.log</pre><p>Let us explore each part of the expdp command</p><ol><li><strong>expdp: —</strong> the Oracle utility to export data.</li><li><strong>username/password: —</strong> The credentials for connecting to the Oracle database.</li><li><strong>connect_string: — </strong>The connection information for the database (e.g host: port/service_name).</li><li><strong>DIRECTORY: —</strong> Specifies the Oracle directory object where the Data Pump files will be stored.</li><li><strong>DUMPFILE:</strong> — Specifies the name of the dump file that will contain the exported data.</li><li><strong>LOGFILE: —</strong> Specifies the name of the log file that will contain the log information for the export.</li></ol><p>Here is the real command with additional parameters to take a <strong>full backup</strong>.</p><pre>expdp system/system123@TESTDB <br>       schemas=T24 <br>       directory=DATA_PUMP_DIR <br>       dumpfile=TESTDB_backup_dump_07_31_2023_12_45%U.dmp <br>       logfile=TESTDB_backup_dump_07_31_2023_12_45.log <br>       parallel=20</pre><p>Schemas=T24 — indicates which database schemas should be exported. It allows you to include multiple schemas (schemas=T24, T25) in a single export operation.</p><p>parallel=20 — indicates the number of <strong>worker processes</strong> for parallel execution during the export, meaning it will create 20 dump files on the directory location.</p><h3><strong>How to take Single Table Backup using Data Pump</strong></h3><p>The above expdp command takes a full backup of Oracle database. Let us consider a scenario where you have to take a backup of one or more tables separately rather than taking a full database backup. In this scenario, you have to add a <strong>TABLES</strong> parameter like below.</p><pre>TABLES=shemas.TABLE_NAME</pre><pre>expdp system/system123@TESTDB <br>       schemas=T24 <br>       directory=DATA_PUMP_DIR <br>       dumpfile=TESTDB_backup_dump_07_31_2023_12_45%U.dmp <br>       logfile=TESTDB_backup_dump_07_31_2023_12_45.log <br>       parallel=20<br>       TABLES=T24.TABLE_NAME</pre><p>If you have to take more than 1 table add a table comma separated.</p><pre>TABLES=T24.TABLE_NAME1,T24.TABLE_NAME2,</pre><h3>How to add encryption to your expdp database export</h3><p>Data Pump offers the capability to perform exports in an encrypted mode, ensuring that encrypted columns are preserved in the resulting dump file. This encryption mode provides various options, including dual, transparent, and password-based encryption. Moreover, you have the flexibility to choose the scope of the encryption application. For instance, you can apply encryption to the complete data and metadata (all), solely to the metadata (metadata_only), or opt for no encryption at all. Let me demonstrate password-based encryption. Here the command below.</p><pre>expdp system/system123@TESTDB<br>       schemas=T24<br>       directory=DATA_PUMP_DIR <br>       dumpfile=TESTDB_backup_dump_07_31_2023_12_45%U.dmp <br>       logfile=TESTDB_backup_dump_07_31_2023_12_45.log<br>       encryption=all<br>       encryption_mode=password<br>       encryption_password=test123<br>       encryption_algorithm=AES256<br>       parallel=20</pre><p>Let us check the parameters</p><ol><li><strong>encryption=all —</strong> Enables encryption for the export operation.</li><li><strong>encryption_password=test123 — </strong>Sets the encryption password to “test123”.</li><li><strong>encryption_algorithm=</strong>AES256 — Specifies the encryption algorithm (AES256)</li></ol><p>You can also add other parameters like compression…etc to your database export. To show you some</p><pre>expdp username/password@connect_string <br>DIRECTORY=directory_object <br>DUMPFILE=dumpfile_name_%U.dmp <br>LOGFILE=log_file.log <br>SCHEMAS=schema_name <br>TABLES=table_name <br>INCLUDE=VIEW,PROCEDURE <br>EXCLUDE=INDEX <br>PARALLEL=4 <br>ESTIMATE_ONLY=Y <br>COMPRESSION=ALL <br>ENCRYPTION=ALL <br>ENCRYPTION_MODE=PASSWORD <br>ENCRYPTION_PASSWORD=encr_password <br>NETWORK_LINK=db_link <br>JOB_NAME=expdp_job <br>FLASHBACK_TIME=SYSTIMESTAMP-1 <br>FLASHBACK_SCN=12345678 <br>CONTENT=ALL</pre><p><strong>Data Pump Import utility (impdp</strong>)</p><p>The Data Pump Import utility, commonly known as impdp, is a tool provided by Oracle for importing data and metadata into Oracle databases. It is part of the Oracle Data Pump, a feature introduced in Oracle Database 10g, offering a high-speed mechanism for moving data and metadata between databases. The impdp utility is the counterpart to the expdp utility used for exporting data.</p><pre>impdp system/system123@TESTDB <br>      schemas=T24 <br>      directory=DATA_PUMP_DIR <br>      dumpfile=TESTDB_backup_dump_07_31_2023_12_45%U.dmp <br>      logfile=TESTDB_backup_dump_07_31_2023_12_45.log<br>      parallel=28 <br>      TABLE_EXISTS_ACTION=REPLACE</pre><p>The TABLE_EXISTS_ACTION parameter in Oracle Data Pump (impdp) determines the behavior when the import process encounters an existing table in the target database. Setting TABLE_EXISTS_ACTION=REPLACE specifies that if a table with the same name already exists in the target schema, it should be replaced or overwritten by the table being imported.</p><p>Let me show common parameters related to impdp</p><pre><br>impdp username/password@connect_string <br>DIRECTORY=directory_object <br>DUMPFILE=dumpfile_name.dmp <br>LOGFILE=log_file.log <br>SCHEMAS=schema_name <br>TABLES=table_name <br>FROMUSER=from_user TOUSER=to_user <br>REMAP_TABLESPACE=old_ts:new_ts <br>REMAP_SCHEMA=old_schema:new_schema <br>REMAP_DATAFILE=old_file:new_file <br>REMAP_TABLE=old_table:new_table <br>REPLACE <br>EXCLUDE=INDEX <br>INCLUDE=VIEW,PROCEDURE <br>NETWORK_LINK=db_link <br>PARALLEL=4 <br>ESTIMATE_ONLY=Y <br>TRANSFORM=SEGMENT_ATTRIBUTES <br>DATA_OPTIONS=SKIP_CONSTRAINT_ERRORS <br>ENCRYPTION_PASSWORD=encr_password <br>TABLE_EXISTS_ACTION=REPLACE <br>REMAP_DATA=old_val:new_val <br>COMMIT=1000</pre><h3>How to Automate Database Export using Shell Scripting</h3><p>To automate the process of taking backups I will be using <strong>cron</strong> since I am my Oracle database running on RHEL machines.<strong> </strong>You can also<strong> Task Scheduler, </strong>if your database is running on<strong> a Windows machine.</strong></p><p>I have created a file on RHEL called exportdb.sh let’s say I take encrypted backup for security purposes</p><pre>#!/bin/bash<br>export ORACLE_BASE= &quot;your path to ORACLE_BASE<br>export ORACLE_HOME=$ORACLE_BASE/Your path to DB_HOME<br>now=`date +%m_%d_%Y_%H_%M`<br>expdp system/system123@TESTDB<br>       schemas=T24<br>       directory=DATA_PUMP_DIR <br>       dumpfile=TESTDB_backup_dump_$now%U.dmp <br>       logfile=TESTDB_backup_dump_$now%U.dmp.log<br>       encryption=all<br>       encryption_mode=password<br>       encryption_password=test123<br>       encryption_algorithm=AES256<br>       parallel=20</pre><p>I scheduled the script to take backup 2 times per day except day 7</p><p>Use “ crontab -e “ to add the scheduled task and</p><p>“ crontab -l “ to list them. In the following scheduled task, the backup starts running at 19 and 23 every day.</p><pre>0 19,23 * * 1–6 /path to your exportdb.sh file</pre><p>In summary, Oracle Data Pump is a feature-rich utility within Oracle Database that facilitates efficient data movement and migration operations. It consists of two key components: Data Pump Export and Data Pump Import. Data Pump Export allows users to extract data and metadata from a source database into a dump file set. This logical representation of database objects can be customized using various options and filters, providing flexibility in selecting the desired data for export. Data Pump Import, on the other hand, enables the loading of data and metadata from a dump file set into a target database. It offers control over the import process, allowing users to specify the location of dump files, choose specific objects to import, and even transform data during the import operation. One of the notable features of Oracle Data Pump is its support for encryption. It allows exports to be performed in an encrypted mode, ensuring that encrypted columns are preserved in the dump file. Different encryption modes, such as dual, transparent, and password-based encryption, are available to cater to various security requirements. Data Pump also provides several performance enhancements. It leverages parallel processing, network-based data movement, and compression techniques to optimize data transfer, resulting in faster and more efficient operations.</p><p>Thank you for reading my article!!</p><p>In part II we will be discussing Recovery Manager (RMAN).</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2b45606a882" width="1" height="1" alt=""><hr><p><a href="https://towardsdev.com/oracle-database-19c-backup-and-recovery-part-i-b2b45606a882">Oracle Database 19c: Backup and Recovery — Part I</a> was originally published in <a href="https://towardsdev.com/">Towards Dev</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>