<?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"><channel><title><![CDATA[ChaiAurCode Assignments]]></title><description><![CDATA[ChaiAurCode Assignments]]></description><link>https://chaiaurcode-assignments.hashnode.dev</link><generator>RSS for Node</generator><lastBuildDate>Sun, 22 Nov 2026 17:02:04 GMT</lastBuildDate><atom:link href="https://chaiaurcode-assignments.hashnode.dev/rss.xml" rel="self" type="application/rss+xml"/><language><![CDATA[en]]></language><ttl>60</ttl><item><title><![CDATA[Emmet for HTML: A Beginner’s Guide to Writing Faster Markup]]></title><description><![CDATA[Learn how Emmet can boost your HTML productivity with shortcuts and simplified syntax for faster, more efficient web development]]></description><link>https://chaiaurcode-assignments.hashnode.dev/emmet-for-html-a-beginners-guide-to-writing-faster-markup</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/emmet-for-html-a-beginners-guide-to-writing-faster-markup</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sun, 01 Feb 2026 14:17:42 GMT</pubDate><content:encoded><![CDATA[<p>If you’ve ever typed a lot of HTML by hand, you’ve probably felt this:</p>
<ul>
<li><p>Writing opening and closing tags again and again</p>
</li>
<li><p>Adding classes and IDs manually</p>
</li>
<li><p>Creating nested structures slowly</p>
</li>
<li><p>Repeating similar elements many times</p>
</li>
</ul>
<p>It works — but it’s slow.</p>
<p>This is where <strong>Emmet</strong> becomes a superpower.</p>
<p>Emmet lets you write <strong>short abbreviations</strong> that instantly expand into full HTML.</p>
<p>Think of it as <strong>shorthand for HTML</strong>.</p>
<hr />
<h2 id="heading-what-is-emmet-very-simple">What is Emmet? (Very Simple)</h2>
<p>Emmet is a tool built into most modern code editors that lets you:</p>
<blockquote>
<p>Type short shortcuts and expand them into full HTML code.</p>
</blockquote>
<p>In simple words:</p>
<blockquote>
<p>Emmet is a shortcut language for writing HTML faster.</p>
</blockquote>
<p>Instead of writing everything manually, you describe what you want — and Emmet writes it for you.</p>
<hr />
<h2 id="heading-why-emmet-is-useful-for-html-beginners">Why Emmet is Useful for HTML Beginners</h2>
<p>For beginners, Emmet helps you:</p>
<p>✅ Write less boilerplate<br />✅ Avoid typing mistakes<br />✅ Focus on structure instead of syntax<br />✅ Learn common HTML patterns faster<br />✅ Build layouts quickly</p>
<p>Emmet doesn’t replace HTML — it just helps you <strong>write HTML faster</strong>.</p>
<hr />
<h2 id="heading-how-emmet-works-inside-code-editors">How Emmet Works Inside Code Editors</h2>
<p>Emmet is built into editors like:</p>
<ul>
<li><p>VS Code (recommended)</p>
</li>
<li><p>Sublime Text</p>
</li>
<li><p>Atom</p>
</li>
<li><p>WebStorm</p>
</li>
</ul>
<p>How it works:</p>
<ol>
<li><p>You type an Emmet abbreviation</p>
</li>
<li><p>You press <strong>Tab</strong> or <strong>Enter</strong></p>
</li>
<li><p>The editor expands it into full HTML</p>
</li>
</ol>
<hr />
<h2 id="heading-life-without-emmet-slow-way">Life Without Emmet (Slow Way)</h2>
<p>Typing this manually:</p>
<pre><code class="lang-plaintext">&lt;div class="card"&gt;
  &lt;h2&gt;Title&lt;/h2&gt;
  &lt;p&gt;Description&lt;/p&gt;
&lt;/div&gt;
</code></pre>
<p>Takes time and repetition.</p>
<hr />
<h2 id="heading-life-with-emmet-fast-way">Life With Emmet (Fast Way)</h2>
<p>Type this:</p>
<pre><code class="lang-plaintext">div.card&gt;h2+p
</code></pre>
<p>Press Tab.</p>
<p>Boom 💥 — full HTML appears.</p>
<hr />
<h2 id="heading-basic-emmet-syntax-core-ideas">Basic Emmet Syntax (Core Ideas)</h2>
<p>Emmet is based on a few simple symbols:</p>
<div class="hn-table">
<table>
<thead>
<tr>
<td>Symbol</td><td>Meaning</td></tr>
</thead>
<tbody>
<tr>
<td><code>&gt;</code></td><td>Child (inside)</td></tr>
<tr>
<td><code>+</code></td><td>Sibling (next to)</td></tr>
<tr>
<td><code>.</code></td><td>Class</td></tr>
<tr>
<td><code>#</code></td><td>ID</td></tr>
<tr>
<td><code>*</code></td><td>Repeat</td></tr>
<tr>
<td><code>[]</code></td><td>Attributes</td></tr>
</tbody>
</table>
</div><p>You don’t need to memorize everything — just these cover most daily use.</p>
<hr />
<h2 id="heading-creating-html-elements">Creating HTML Elements</h2>
<h3 id="heading-example">Example</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">p
</code></pre>
<p>Expands to:</p>
<pre><code class="lang-plaintext">&lt;p&gt;&lt;/p&gt;
</code></pre>
<hr />
<h2 id="heading-adding-classes-and-ids">Adding Classes and IDs</h2>
<h3 id="heading-class">Class</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">p.highlight
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;p class="highlight"&gt;&lt;/p&gt;
</code></pre>
<hr />
<h3 id="heading-id">ID</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">h1#main-title
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;h1 id="main-title"&gt;&lt;/h1&gt;
</code></pre>
<hr />
<h2 id="heading-adding-attributes">Adding Attributes</h2>
<p>Use square brackets <code>[]</code>.</p>
<h3 id="heading-example-1">Example</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">img[src="photo.jpg" alt="My Photo"]
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;img src="photo.jpg" alt="My Photo"&gt;
</code></pre>
<hr />
<h2 id="heading-creating-nested-elements">Creating Nested Elements</h2>
<p>Use <code>&gt;</code> for child elements.</p>
<h3 id="heading-example-2">Example</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">div&gt;p
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;div&gt;
  &lt;p&gt;&lt;/p&gt;
&lt;/div&gt;
</code></pre>
<hr />
<h3 id="heading-multiple-levels">Multiple Levels</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">div&gt;ul&gt;li
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;div&gt;
  &lt;ul&gt;
    &lt;li&gt;&lt;/li&gt;
  &lt;/ul&gt;
&lt;/div&gt;
</code></pre>
<hr />
<h2 id="heading-creating-sibling-elements">Creating Sibling Elements</h2>
<p>Use <code>+</code> for elements at the same level.</p>
<h3 id="heading-example-3">Example</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">h1+p
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;h1&gt;&lt;/h1&gt;
&lt;p&gt;&lt;/p&gt;
</code></pre>
<hr />
<h2 id="heading-repeating-elements-multiplication">Repeating Elements (Multiplication)</h2>
<p>Use <code>*</code> to repeat elements.</p>
<h3 id="heading-example-4">Example</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">li*3
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;li&gt;&lt;/li&gt;
&lt;li&gt;&lt;/li&gt;
&lt;li&gt;&lt;/li&gt;
</code></pre>
<hr />
<h3 id="heading-repeating-with-structure">Repeating with Structure</h3>
<p>Emmet:</p>
<pre><code class="lang-plaintext">ul&gt;li*3
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;ul&gt;
  &lt;li&gt;&lt;/li&gt;
  &lt;li&gt;&lt;/li&gt;
  &lt;li&gt;&lt;/li&gt;
&lt;/ul&gt;
</code></pre>
<hr />
<h2 id="heading-combining-everything-realistic-example">Combining Everything (Realistic Example)</h2>
<p>Emmet:</p>
<pre><code class="lang-plaintext">div.card&gt;h2.title+p.desc+a.btn
</code></pre>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;div class="card"&gt;
  &lt;h2 class="title"&gt;&lt;/h2&gt;
  &lt;p class="desc"&gt;&lt;/p&gt;
  &lt;a href="" class="btn"&gt;&lt;/a&gt;
&lt;/div&gt;
</code></pre>
<hr />
<h2 id="heading-generating-full-html-boilerplate">Generating Full HTML Boilerplate</h2>
<p>This is a favorite.</p>
<p>Type:</p>
<pre><code class="lang-plaintext">!
</code></pre>
<p>or</p>
<pre><code class="lang-plaintext">html:5
</code></pre>
<p>Press Tab.</p>
<p>You get:</p>
<pre><code class="lang-plaintext">&lt;!DOCTYPE html&gt;
&lt;html lang="en"&gt;
&lt;head&gt;
  &lt;meta charset="UTF-8"&gt;
  &lt;title&gt;Document&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;

&lt;/body&gt;
&lt;/html&gt;
</code></pre>
<p>Huge time saver.</p>
<hr />
<h2 id="heading-side-by-side-how-emmet-thinks">Side-by-Side: How Emmet Thinks</h2>
<h3 id="heading-abbreviation-html">Abbreviation → HTML</h3>
<pre><code class="lang-plaintext">div.container&gt;h1+p*2
</code></pre>
<p>↓</p>
<pre><code class="lang-plaintext">&lt;div class="container"&gt;
  &lt;h1&gt;&lt;/h1&gt;
  &lt;p&gt;&lt;/p&gt;
  &lt;p&gt;&lt;/p&gt;
&lt;/div&gt;
</code></pre>
<p>This helps you think in <strong>structure</strong>, not typing.</p>
<hr />
<h2 id="heading-emmet-workflow-daily-use">Emmet Workflow (Daily Use)</h2>
<p>Typical flow:</p>
<ol>
<li><p>Think of structure</p>
</li>
<li><p>Type Emmet abbreviation</p>
</li>
<li><p>Press Tab</p>
</li>
<li><p>Fill in content</p>
</li>
</ol>
<p>You build layouts extremely fast.</p>
<hr />
<h2 id="heading-important-emmet-is-optional-but-powerful">Important: Emmet is Optional (But Powerful)</h2>
<p>You can write HTML without Emmet.</p>
<p>But once you get used to it:</p>
<ul>
<li><p>You’ll never want to go back</p>
</li>
<li><p>Your speed will increase a lot</p>
</li>
<li><p>Your focus shifts to layout and design</p>
</li>
</ul>
<p>It’s like using keyboard shortcuts instead of menus.</p>
<hr />
<h2 id="heading-diagram-ideas-for-your-blog">Diagram Ideas for Your Blog</h2>
<h3 id="heading-1-emmet-expansion-flow">1. Emmet Expansion Flow</h3>
<pre><code class="lang-plaintext">Emmet Abbreviation
        ↓
   Editor Expansion
        ↓
     Full HTML
</code></pre>
<hr />
<h3 id="heading-2-nested-structure">2. Nested Structure</h3>
<pre><code class="lang-plaintext">div&gt;ul&gt;li*3
</code></pre>
<p>↓</p>
<pre><code class="lang-plaintext">div
 └── ul
      ├── li
      ├── li
      └── li
</code></pre>
<hr />
<p>Credit: Chatgpt</p>
]]></content:encoded></item><item><title><![CDATA[CSS Selectors 101: Targeting Elements with Precision]]></title><description><![CDATA[Learn CSS selectors to target HTML elements with precision: element, class, ID, group, and descendant selectors simplified for beginners]]></description><link>https://chaiaurcode-assignments.hashnode.dev/css-selectors-101-targeting-elements-with-precision</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/css-selectors-101-targeting-elements-with-precision</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><category><![CDATA[CSS]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sun, 01 Feb 2026 14:14:13 GMT</pubDate><content:encoded><![CDATA[<p>When you write CSS, you’re not just saying <em>what</em> styles to apply — you’re also saying <strong>who</strong> should get those styles.</p>
<p>That’s what <strong>CSS selectors</strong> are for.</p>
<p>Selectors are how CSS <strong>chooses elements</strong> on a web page.</p>
<p>If HTML is the structure, CSS selectors are how you <strong>point to specific parts</strong> of that structure.</p>
<p>Let’s break it down in a simple, practical way.</p>
<hr />
<h2 id="heading-why-css-selectors-are-needed">Why CSS Selectors Are Needed</h2>
<p>Imagine a classroom full of students.</p>
<p>If you say:</p>
<blockquote>
<p>“Everyone wear a blue shirt.”</p>
</blockquote>
<p>That’s like an <strong>element selector</strong>.</p>
<p>If you say:</p>
<blockquote>
<p>“Everyone in the front row wear a blue shirt.”</p>
</blockquote>
<p>That’s like a <strong>class selector</strong>.</p>
<p>If you say:</p>
<blockquote>
<p>“Only John wear a blue shirt.”</p>
</blockquote>
<p>That’s like an <strong>ID selector</strong>.</p>
<p>CSS selectors are how you <strong>target</strong> elements with different levels of precision.</p>
<hr />
<h2 id="heading-selectors-ways-to-choose-elements">Selectors = Ways to Choose Elements</h2>
<p>In simple words:</p>
<blockquote>
<p>A CSS selector tells the browser which HTML elements to apply styles to.</p>
</blockquote>
<p>Format:</p>
<pre><code class="lang-plaintext">selector {
  property: value;
}
</code></pre>
<hr />
<h2 id="heading-1-element-selector">1. Element Selector</h2>
<p>Targets all elements of a given type.</p>
<h3 id="heading-example">Example</h3>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;p&gt;Hello&lt;/p&gt;
&lt;p&gt;World&lt;/p&gt;
</code></pre>
<p>CSS:</p>
<pre><code class="lang-plaintext">p {
  color: blue;
}
</code></pre>
<h3 id="heading-result">Result</h3>
<p>All <code>&lt;p&gt;</code> elements become blue.</p>
<h3 id="heading-analogy">Analogy</h3>
<p>🧍 “All students wear blue.”</p>
<hr />
<h2 id="heading-2-class-selector">2. Class Selector</h2>
<p>Targets elements with a specific class.</p>
<p>Class selector uses a dot <code>.</code></p>
<h3 id="heading-example-1">Example</h3>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;p class="highlight"&gt;Important&lt;/p&gt;
&lt;p&gt;Normal&lt;/p&gt;
</code></pre>
<p>CSS:</p>
<pre><code class="lang-plaintext">.highlight {
  color: red;
}
</code></pre>
<h3 id="heading-result-1">Result</h3>
<p>Only elements with class <code>highlight</code> turn red.</p>
<h3 id="heading-analogy-1">Analogy</h3>
<p>🧍‍♂️ “All students wearing red badges.”</p>
<hr />
<h2 id="heading-3-id-selector">3. ID Selector</h2>
<p>Targets one unique element.</p>
<p>ID selector uses a hash <code>#</code></p>
<h3 id="heading-example-2">Example</h3>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;h1 id="main-title"&gt;Welcome&lt;/h1&gt;
</code></pre>
<p>CSS:</p>
<pre><code class="lang-plaintext">#main-title {
  color: green;
}
</code></pre>
<h3 id="heading-result-2">Result</h3>
<p>Only that one element is styled.</p>
<h3 id="heading-analogy-2">Analogy</h3>
<p>🧍 “Only John.”</p>
<hr />
<h2 id="heading-class-vs-id-important-beginner-rule">Class vs ID (Important Beginner Rule)</h2>
<div class="hn-table">
<table>
<thead>
<tr>
<td>Feature</td><td>Class</td><td>ID</td></tr>
</thead>
<tbody>
<tr>
<td>Symbol</td><td><code>.</code></td><td><code>#</code></td></tr>
<tr>
<td>Can repeat?</td><td>Yes</td><td>No (unique)</td></tr>
<tr>
<td>Use for</td><td>Groups</td><td>Single unique element</td></tr>
</tbody>
</table>
</div><hr />
<h2 id="heading-4-group-selectors">4. Group Selectors</h2>
<p>Apply same styles to multiple selectors.</p>
<p>Use commas <code>,</code></p>
<h3 id="heading-example-3">Example</h3>
<pre><code class="lang-plaintext">h1, h2, p {
  font-family: Arial;
}
</code></pre>
<h3 id="heading-meaning">Meaning</h3>
<p>Apply to:</p>
<ul>
<li><p>All h1</p>
</li>
<li><p>All h2</p>
</li>
<li><p>All p</p>
</li>
</ul>
<h3 id="heading-analogy-3">Analogy</h3>
<p>👥 “John, Mary, and Alex — wear blue.”</p>
<hr />
<h2 id="heading-5-descendant-selectors">5. Descendant Selectors</h2>
<p>Targets elements <strong>inside other elements</strong>.</p>
<p>Format:</p>
<pre><code class="lang-plaintext">parent child {
}
</code></pre>
<h3 id="heading-example-4">Example</h3>
<p>HTML:</p>
<pre><code class="lang-plaintext">&lt;div&gt;
  &lt;p&gt;Hello&lt;/p&gt;
&lt;/div&gt;

&lt;p&gt;Outside&lt;/p&gt;
</code></pre>
<p>CSS:</p>
<pre><code class="lang-plaintext">div p {
  color: purple;
}
</code></pre>
<h3 id="heading-result-3">Result</h3>
<p>Only <code>&lt;p&gt;</code> inside <code>&lt;div&gt;</code> becomes purple.</p>
<h3 id="heading-analogy-4">Analogy</h3>
<p>🏫 “Students inside classroom A.”</p>
<hr />
<h2 id="heading-basic-selector-priority-very-high-level">Basic Selector Priority (Very High Level)</h2>
<p>When multiple selectors target the same element, CSS decides which one wins.</p>
<p>Very simplified:</p>
<pre><code class="lang-plaintext">ID &gt; Class &gt; Element
</code></pre>
<p>So:</p>
<ul>
<li><p>ID selector has highest priority</p>
</li>
<li><p>Class is in the middle</p>
</li>
<li><p>Element is lowest</p>
</li>
</ul>
<h3 id="heading-example-5">Example</h3>
<pre><code class="lang-plaintext">p { color: blue; }
.highlight { color: red; }
#main { color: green; }
</code></pre>
<p>If an element matches all three, <strong>green wins</strong>.</p>
<hr />
<h2 id="heading-before-after-example">Before / After Example</h2>
<h3 id="heading-html">HTML</h3>
<pre><code class="lang-plaintext">&lt;p class="highlight" id="main"&gt;Hello&lt;/p&gt;
</code></pre>
<h3 id="heading-css">CSS</h3>
<pre><code class="lang-plaintext">p { color: blue; }
.highlight { color: red; }
#main { color: green; }
</code></pre>
<h3 id="heading-final-color">Final Color</h3>
<p>✅ Green (ID wins)</p>
<hr />
<h2 id="heading-why-selectors-are-the-foundation-of-css">Why Selectors Are the Foundation of CSS</h2>
<p>Almost everything in CSS depends on selectors:</p>
<ul>
<li><p>Styling layouts</p>
</li>
<li><p>Responsive design</p>
</li>
<li><p>Animations</p>
</li>
<li><p>Themes</p>
</li>
<li><p>Component styling</p>
</li>
</ul>
<p>If you understand selectors well, CSS becomes much easier.</p>
<hr />
<h2 id="heading-diagram-ideas-for-your-blog">Diagram Ideas for Your Blog</h2>
<h3 id="heading-1-selector-targeting-flow">1. Selector Targeting Flow</h3>
<pre><code class="lang-plaintext">Element → Class → ID
(Broad)        (Specific)
</code></pre>
<hr />
<h3 id="heading-2-class-vs-id">2. Class vs ID</h3>
<pre><code class="lang-plaintext">.class   → Group
#id      → Unique
</code></pre>
<hr />
<h2 id="heading-beginner-tips">Beginner Tips</h2>
<ul>
<li><p>Use <strong>classes</strong> most of the time</p>
</li>
<li><p>Use <strong>IDs</strong> sparingly</p>
</li>
<li><p>Avoid over-styling with element selectors</p>
</li>
<li><p>Practice with small examples</p>
</li>
</ul>
<hr />
<p>Credit: Chatgpt</p>
]]></content:encoded></item><item><title><![CDATA[Understanding HTML Tags and Elements]]></title><description><![CDATA[Learn HTML basics: understand tags, elements, block vs inline, and more. Perfect for web development beginners seeking to grasp webpage structure]]></description><link>https://chaiaurcode-assignments.hashnode.dev/understanding-html-tags-and-elements</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/understanding-html-tags-and-elements</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><category><![CDATA[HTML5]]></category><category><![CDATA[HTML]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sun, 01 Feb 2026 14:10:01 GMT</pubDate><content:encoded><![CDATA[<p>Every website you’ve ever visited is built on <strong>HTML</strong>.</p>
<p>Before CSS makes things look good and JavaScript makes things interactive, HTML provides the <strong>structure</strong> — the skeleton — of a webpage.</p>
<p>If you’re learning web development, understanding HTML properly is your first big step.</p>
<p>Let’s break it down simply.</p>
<hr />
<h2 id="heading-what-is-html-and-why-do-we-use-it">What is HTML and Why Do We Use It?</h2>
<p>HTML stands for <strong>HyperText Markup Language</strong>.</p>
<p>HTML is used to:</p>
<ul>
<li><p>Define the structure of a webpage</p>
</li>
<li><p>Tell the browser what content exists</p>
</li>
<li><p>Organize text, images, links, and sections</p>
</li>
</ul>
<p>In simple words:</p>
<blockquote>
<p>HTML is the skeleton of a webpage.</p>
</blockquote>
<p>Just like a human skeleton gives shape to a body, HTML gives structure to a website.</p>
<hr />
<h2 id="heading-what-is-an-html-tag">What is an HTML Tag?</h2>
<p>An HTML <strong>tag</strong> is a keyword wrapped in angle brackets:</p>
<pre><code class="lang-plaintext">&lt;p&gt;
</code></pre>
<p>Tags tell the browser:</p>
<blockquote>
<p>“This is a paragraph”<br />“This is a heading”<br />“This is a division/section”</p>
</blockquote>
<p>Think of a tag like a <strong>label on a box</strong>.</p>
<hr />
<h2 id="heading-opening-tag-closing-tag-and-content">Opening Tag, Closing Tag, and Content</h2>
<p>Most HTML tags come in pairs:</p>
<pre><code class="lang-plaintext">&lt;p&gt;Hello World&lt;/p&gt;
</code></pre>
<p>Breakdown:</p>
<ul>
<li><p><code>&lt;p&gt;</code> → Opening tag</p>
</li>
<li><p><code>Hello World</code> → Content</p>
</li>
<li><p><code>&lt;/p&gt;</code> → Closing tag</p>
</li>
</ul>
<p>The closing tag has a <code>/</code> to show the end.</p>
<hr />
<h2 id="heading-what-is-an-html-element">What is an HTML Element?</h2>
<p>This is a very common beginner confusion.</p>
<h3 id="heading-tag-vs-element">Tag vs Element</h3>
<h3 id="heading-html-tag">HTML Tag:</h3>
<p>Just the label:</p>
<pre><code class="lang-plaintext">&lt;p&gt;
</code></pre>
<h3 id="heading-html-element">HTML Element:</h3>
<p>The <strong>complete thing</strong>:</p>
<pre><code class="lang-plaintext">&lt;p&gt;Hello World&lt;/p&gt;
</code></pre>
<p>So:</p>
<blockquote>
<p>An HTML element = opening tag + content + closing tag</p>
</blockquote>
<hr />
<h2 id="heading-simple-box-analogy">Simple Box Analogy</h2>
<p>Think of an element like a box:</p>
<pre><code class="lang-plaintext">+------------------+
|   Hello World   |
+------------------+
</code></pre>
<ul>
<li><p>Opening tag = Start of box</p>
</li>
<li><p>Content = What’s inside</p>
</li>
<li><p>Closing tag = End of box</p>
</li>
</ul>
<hr />
<h2 id="heading-self-closing-void-elements">Self-Closing (Void) Elements</h2>
<p>Some HTML elements don’t wrap content.</p>
<p>They don’t have closing tags.</p>
<p>Examples:</p>
<pre><code class="lang-plaintext">&lt;img src="photo.jpg"&gt;
&lt;br&gt;
&lt;input&gt;
&lt;hr&gt;
</code></pre>
<p>These are called:</p>
<ul>
<li><p>Self-closing elements</p>
</li>
<li><p>Void elements</p>
</li>
</ul>
<p>They represent things like:</p>
<ul>
<li><p>Images</p>
</li>
<li><p>Line breaks</p>
</li>
<li><p>Inputs</p>
</li>
<li><p>Horizontal lines</p>
</li>
</ul>
<p>They don’t contain text content inside.</p>
<hr />
<h2 id="heading-block-level-vs-inline-elements">Block-Level vs Inline Elements</h2>
<p>HTML elements are generally either:</p>
<ul>
<li><p>Block-level</p>
</li>
<li><p>Inline</p>
</li>
</ul>
<p>This affects <strong>layout</strong>.</p>
<hr />
<h2 id="heading-block-level-elements">Block-Level Elements</h2>
<p>Block elements:</p>
<ul>
<li><p>Start on a new line</p>
</li>
<li><p>Take full width by default</p>
</li>
</ul>
<p>Examples:</p>
<pre><code class="lang-plaintext">&lt;h1&gt;Heading&lt;/h1&gt;
&lt;p&gt;Paragraph&lt;/p&gt;
&lt;div&gt;Division&lt;/div&gt;
</code></pre>
<h3 id="heading-visual-idea">Visual Idea:</h3>
<pre><code class="lang-plaintext">[ Heading            ]
[ Paragraph          ]
[ Division           ]
</code></pre>
<p>Each block sits on its own line.</p>
<hr />
<h2 id="heading-inline-elements">Inline Elements</h2>
<p>Inline elements:</p>
<ul>
<li><p>Stay in the same line</p>
</li>
<li><p>Take only needed width</p>
</li>
</ul>
<p>Examples:</p>
<pre><code class="lang-plaintext">&lt;span&gt;Text&lt;/span&gt;
&lt;a&gt;Link&lt;/a&gt;
&lt;strong&gt;Bold&lt;/strong&gt;
</code></pre>
<h3 id="heading-visual-idea-1">Visual Idea:</h3>
<pre><code class="lang-plaintext">This is [span] inside a sentence.
</code></pre>
<p>They flow with text.</p>
<hr />
<h2 id="heading-commonly-used-html-tags-beginner-list">Commonly Used HTML Tags (Beginner List)</h2>
<p>Here are some core tags you’ll use all the time:</p>
<h3 id="heading-headings">Headings</h3>
<pre><code class="lang-plaintext">&lt;h1&gt;Main Heading&lt;/h1&gt;
&lt;h2&gt;Sub Heading&lt;/h2&gt;
&lt;h3&gt;Smaller Heading&lt;/h3&gt;
</code></pre>
<hr />
<h3 id="heading-paragraph">Paragraph</h3>
<pre><code class="lang-plaintext">&lt;p&gt;This is a paragraph.&lt;/p&gt;
</code></pre>
<hr />
<h3 id="heading-division-generic-container">Division (Generic Container)</h3>
<pre><code class="lang-plaintext">&lt;div&gt;Some content&lt;/div&gt;
</code></pre>
<p>Used to group elements.</p>
<hr />
<h3 id="heading-span-inline-container">Span (Inline Container)</h3>
<pre><code class="lang-plaintext">&lt;span&gt;Highlighted text&lt;/span&gt;
</code></pre>
<p>Used inside text.</p>
<hr />
<h3 id="heading-links">Links</h3>
<pre><code class="lang-plaintext">&lt;a href="https://example.com"&gt;Visit&lt;/a&gt;
</code></pre>
<hr />
<h3 id="heading-images">Images</h3>
<pre><code class="lang-plaintext">&lt;img src="image.jpg" alt="My Image"&gt;
</code></pre>
<hr />
<h3 id="heading-line-break">Line Break</h3>
<pre><code class="lang-plaintext">&lt;br&gt;
</code></pre>
<hr />
<h2 id="heading-encourage-inspect-html-in-the-browser">Encourage: Inspect HTML in the Browser</h2>
<p>One of the best ways to learn HTML is:</p>
<blockquote>
<p>Right-click → Inspect</p>
</blockquote>
<p>You can:</p>
<ul>
<li><p>See real HTML of websites</p>
</li>
<li><p>Explore DOM structure</p>
</li>
<li><p>Understand how elements are nested</p>
</li>
</ul>
<p>This builds intuition fast.</p>
<hr />
<h2 id="heading-keep-it-simple-as-a-beginner">Keep It Simple as a Beginner</h2>
<p>You don’t need to learn:</p>
<ul>
<li><p>Every HTML tag</p>
</li>
<li><p>Advanced semantic tags</p>
</li>
<li><p>Accessibility rules (yet)</p>
</li>
</ul>
<p>Focus first on:</p>
<ul>
<li><p>Structure</p>
</li>
<li><p>Tags vs elements</p>
</li>
<li><p>Block vs inline</p>
</li>
<li><p>Nesting elements</p>
</li>
</ul>
<hr />
<h2 id="heading-diagram-ideas-for-your-blog">Diagram Ideas for Your Blog</h2>
<h3 id="heading-1-tag-vs-element">1. Tag vs Element</h3>
<pre><code class="lang-plaintext">&lt;p&gt; Hello &lt;/p&gt;
 ^    ^     ^
Tag  Content Tag
</code></pre>
<p>Element = Entire line</p>
<hr />
<h3 id="heading-2-block-vs-inline-layout">2. Block vs Inline Layout</h3>
<pre><code class="lang-plaintext">Block:
[ div              ]
[ p                ]
[ h1               ]

Inline:
Text [span] more text [a]
</code></pre>
<hr />
<p>Credit: Chatgpt</p>
]]></content:encoded></item><item><title><![CDATA[How a Browser Works: A Beginner-Friendly Guide to Browser Internals]]></title><description><![CDATA[Learn how browsers work internally, from parsing HTML to rendering pixels. Discover how this knowledge helps improve web performance]]></description><link>https://chaiaurcode-assignments.hashnode.dev/how-a-browser-works-a-beginner-friendly-guide-to-browser-internals</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/how-a-browser-works-a-beginner-friendly-guide-to-browser-internals</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sun, 01 Feb 2026 14:06:19 GMT</pubDate><content:encoded><![CDATA[<h1>What Really Happens Inside a Browser? (From URL to Pixels)</h1>
<p>When you type a URL and press <strong>Enter</strong>, it feels instant.</p>
<p>But inside your browser, <strong>dozens of systems start working together</strong> to turn text like:</p>
<pre><code class="language-plaintext">https://example.com
</code></pre>
<p>into a fully rendered web page with layout, colors, images, and interactivity.</p>
<p>A browser is not just something that “opens websites.”<br />It’s a complex software system that <strong>downloads, understands, and draws the web</strong>.</p>
<p>Let’s walk through the full story — visually and simply.</p>
<hr />
<h2>First Question: What Happens After I Press Enter?</h2>
<p>Here’s the big-picture flow:</p>
<ol>
<li><p>Browser figures out where the website is</p>
</li>
<li><p>Browser downloads HTML, CSS, and JavaScript</p>
</li>
<li><p>Browser understands (parses) that code</p>
</li>
<li><p>Browser builds internal structures (DOM &amp; CSSOM)</p>
</li>
<li><p>Browser calculates layout</p>
</li>
<li><p>Browser paints pixels on your screen</p>
</li>
</ol>
<p>All of this happens in milliseconds.</p>
<hr />
<h2>What Is a Browser (Beyond “It Opens Websites”)?</h2>
<p>At a high level, a browser is:</p>
<blockquote>
<p>A program that fetches web resources, understands them, and converts them into pixels on your screen.</p>
</blockquote>
<p>A browser must be able to:</p>
<ul>
<li><p>Talk to servers over the network</p>
</li>
<li><p>Read and understand HTML, CSS, and JavaScript</p>
</li>
<li><p>Calculate layout and sizes</p>
</li>
<li><p>Draw text, colors, images, and shapes</p>
</li>
<li><p>Handle user input (clicks, scrolls, typing)</p>
</li>
</ul>
<p>So a browser is really a <strong>collection of specialized components</strong>.</p>
<hr />
<h2>Main Parts of a Browser (High-Level)</h2>
<p>Think of a browser like a company with different departments:</p>
<h3>1. User Interface (UI)</h3>
<p>This is what you see and interact with:</p>
<ul>
<li><p>Address bar</p>
</li>
<li><p>Tabs</p>
</li>
<li><p>Back/forward buttons</p>
</li>
<li><p>Refresh button</p>
</li>
<li><p>Bookmarks</p>
</li>
</ul>
<p>This part is NOT the web page itself — it’s the browser’s own UI.</p>
<hr />
<h3>2. Browser Engine (Coordinator)</h3>
<p>The browser engine:</p>
<ul>
<li><p>Coordinates between UI and rendering</p>
</li>
<li><p>Decides when to load a page</p>
</li>
<li><p>Tells other components what to do</p>
</li>
</ul>
<p>Think of it as the <strong>manager</strong>.</p>
<hr />
<h3>3. Rendering Engine (Page Painter)</h3>
<p>The rendering engine is responsible for:</p>
<ul>
<li><p>Understanding HTML and CSS</p>
</li>
<li><p>Building page structure</p>
</li>
<li><p>Calculating layout</p>
</li>
<li><p>Painting pixels</p>
</li>
</ul>
<p>This is the part that actually <strong>draws the web page</strong>.</p>
<p>Examples (just names, no deep dive):</p>
<ul>
<li><p>Chromium (Blink)</p>
</li>
<li><p>Firefox (Gecko)</p>
</li>
<li><p>Safari (WebKit)</p>
</li>
</ul>
<hr />
<h3>4. Networking</h3>
<p>This part handles:</p>
<ul>
<li><p>Sending HTTP requests</p>
</li>
<li><p>Receiving HTML, CSS, JS, images</p>
</li>
<li><p>Talking to web servers</p>
</li>
</ul>
<p>It’s like the <strong>delivery system</strong>.</p>
<hr />
<h3>5. JavaScript Engine</h3>
<p>This part:</p>
<ul>
<li><p>Executes JavaScript code</p>
</li>
<li><p>Handles logic, events, and interactions</p>
</li>
</ul>
<p>Examples:</p>
<ul>
<li><p>V8 (Chrome)</p>
</li>
<li><p>SpiderMonkey (Firefox)</p>
</li>
</ul>
<hr />
<h2>How the Browser Fetches a Page</h2>
<p>After you press Enter:</p>
<ol>
<li><p>Browser sends an HTTP request</p>
</li>
<li><p>Server responds with HTML</p>
</li>
<li><p>Browser also downloads:</p>
<ul>
<li><p>CSS files</p>
</li>
<li><p>JavaScript files</p>
</li>
<li><p>Images, fonts, etc.</p>
</li>
</ul>
</li>
</ol>
<p>Now the browser has raw text files.</p>
<p>Next step: <strong>understanding them.</strong></p>
<hr />
<h2>HTML Parsing and DOM Creation</h2>
<p>The browser reads HTML and <strong>parses</strong> it.</p>
<h3>What is Parsing? (Simple Idea)</h3>
<p>Parsing means:</p>
<blockquote>
<p>Breaking raw text into meaningful structure.</p>
</blockquote>
<hr />
<h3>Simple Parsing Example (Math)</h3>
<p>Expression:</p>
<pre><code class="language-plaintext">2 + 3 * 4
</code></pre>
<p>Parser understands structure:</p>
<pre><code class="language-plaintext">   +
  / \
 2   *
    / \
   3   4
</code></pre>
<p>It’s not just text — it becomes a <strong>tree structure</strong>.</p>
<hr />
<h3>HTML → DOM (Document Object Model)</h3>
<p>HTML like this:</p>
<pre><code class="language-plaintext">&lt;body&gt;
  &lt;h1&gt;Hello&lt;/h1&gt;
  &lt;p&gt;World&lt;/p&gt;
&lt;/body&gt;
</code></pre>
<p>Becomes a tree (DOM):</p>
<pre><code class="language-plaintext">body
 ├── h1
 │    └── "Hello"
 └── p
      └── "World"
</code></pre>
<h3>DOM = Tree of the page structure</h3>
<p>Think of DOM as:</p>
<p>🌳 A tree that represents every element on the page.</p>
<hr />
<h2>CSS Parsing and CSSOM Creation</h2>
<p>CSS is also parsed.</p>
<p>CSS like:</p>
<pre><code class="language-plaintext">p { color: red; }
</code></pre>
<p>Becomes another structure called:</p>
<h3>CSSOM (CSS Object Model)</h3>
<p>CSSOM represents:</p>
<ul>
<li><p>Styles</p>
</li>
<li><p>Rules</p>
</li>
<li><p>Which elements they apply to</p>
</li>
</ul>
<p>So now the browser has:</p>
<ul>
<li><p>DOM → Structure</p>
</li>
<li><p>CSSOM → Styles</p>
</li>
</ul>
<hr />
<h2>DOM + CSSOM → Render Tree</h2>
<p>The browser combines:</p>
<ul>
<li><p>DOM (what elements exist)</p>
</li>
<li><p>CSSOM (how they look)</p>
</li>
</ul>
<p>To create the:</p>
<h3>Render Tree</h3>
<p>The Render Tree contains:</p>
<ul>
<li><p>Only visible elements</p>
</li>
<li><p>With final computed styles</p>
</li>
</ul>
<p>This is what the browser actually uses to draw.</p>
<hr />
<h2>Layout (Reflow)</h2>
<p>Now the browser calculates:</p>
<ul>
<li><p>Widths</p>
</li>
<li><p>Heights</p>
</li>
<li><p>Positions</p>
</li>
<li><p>Where each element goes on screen</p>
</li>
</ul>
<p>This step is called:</p>
<h3>Layout (or Reflow)</h3>
<p>It answers:</p>
<blockquote>
<p>Where exactly should every box be placed?</p>
</blockquote>
<hr />
<h2>Painting</h2>
<p>After layout, the browser:</p>
<ul>
<li><p>Fills colors</p>
</li>
<li><p>Draws text</p>
</li>
<li><p>Draws borders</p>
</li>
<li><p>Draws images</p>
</li>
</ul>
<p>This step is called:</p>
<h3>Painting</h3>
<p>It’s like painting a canvas layer by layer.</p>
<hr />
<h2>Display (Compositing)</h2>
<p>Finally:</p>
<ul>
<li><p>All painted layers are combined</p>
</li>
<li><p>Pixels are sent to your screen</p>
</li>
</ul>
<p>You see the web page 🎉</p>
<hr />
<h2>Full Flow: From URL to Pixels</h2>
<p>Here’s the full story in one view:</p>
<pre><code class="language-plaintext">URL Entered
     ↓
Networking (HTTP)
     ↓
HTML → DOM
CSS  → CSSOM
     ↓
DOM + CSSOM
     ↓
Render Tree
     ↓
Layout (Reflow)
     ↓
Paint
     ↓
Display Pixels
</code></pre>
<hr />
<h2>Why This Matters for Web Developers</h2>
<p>Understanding this helps you:</p>
<ul>
<li><p>Write faster websites</p>
</li>
<li><p>Avoid unnecessary reflows</p>
</li>
<li><p>Understand performance issues</p>
</li>
<li><p>Debug rendering problems</p>
</li>
<li><p>Understand why CSS/JS can block rendering</p>
</li>
</ul>
<hr />
<h2>Don’t Try to Memorize Everything</h2>
<p>As a beginner, you do NOT need to memorize:</p>
<ul>
<li><p>All internal engines</p>
</li>
<li><p>All optimization tricks</p>
</li>
<li><p>All parsing rules</p>
</li>
</ul>
<p>What matters is the <strong>flow and big picture</strong>.</p>
<p>Over time, these ideas will become natural.</p>
<hr />
<h2>Final Summary</h2>
<ul>
<li><p>A browser is a system of components, not just a viewer</p>
</li>
<li><p>HTML becomes DOM (structure)</p>
</li>
<li><p>CSS becomes CSSOM (styles)</p>
</li>
<li><p>DOM + CSSOM become Render Tree</p>
</li>
<li><p>Render Tree goes through Layout and Paint</p>
</li>
</ul>
<p>Pixels appear on your screenWhat Really Happens Inside a Browser? (From URL to Pixels)</p>
<p>When you type a URL and press <strong>Enter</strong>, it feels instant.</p>
<p>But inside your browser, <strong>dozens of systems start working together</strong> to turn text like:</p>
<pre><code class="language-plaintext">https://example.com
</code></pre>
<p>into a fully rendered web page with layout, colors, images, and interactivity.</p>
<p>A browser is not just something that “opens websites.”<br />It’s a complex software system that <strong>downloads, understands, and draws the web</strong>.</p>
<p>Let’s walk through the full story — visually and simply.</p>
<hr />
<p>Diagram:</p>
<img src="https://cloudmate-test.s3.us-east-1.amazonaws.com/uploads/covers/686cf1ce69df99351f61b6b1/ef907c2b-3651-41f9-ae56-c1aa8d38139d.png" alt="" style="display:block;margin:0 auto" />

<hr />
<p>Credit: Chatgpt</p>
]]></content:encoded></item><item><title><![CDATA[TCP Working: 3-Way Handshake & Reliable Communication]]></title><description><![CDATA[Learn how TCP ensures reliable, ordered communication via the 3-way handshake, managing packet loss, duplicates, and connection integrity]]></description><link>https://chaiaurcode-assignments.hashnode.dev/tcp-working-3-way-handshake-and-reliable-communication</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/tcp-working-3-way-handshake-and-reliable-communication</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sun, 01 Feb 2026 14:02:36 GMT</pubDate><content:encoded><![CDATA[<p>When two computers communicate over the internet, they don’t just start sending data randomly. Without rules, messages could be lost, arrive out of order, or get mixed up.</p>
<p>That’s exactly why <strong>TCP (Transmission Control Protocol)</strong> exists.</p>
<p>TCP is one of the most important protocols on the internet. It makes communication <strong>reliable, ordered, and correct</strong>.</p>
<p>Let’s break TCP down step by step — without drowning in packet-level complexity.</p>
<hr />
<h2 id="heading-what-happens-if-data-is-sent-without-rules">What Happens If Data Is Sent Without Rules?</h2>
<p>Imagine two people trying to talk by throwing papers across a windy field.</p>
<p>Problems you’d face:</p>
<ul>
<li><p>Some papers never arrive</p>
</li>
<li><p>Papers arrive in the wrong order</p>
</li>
<li><p>Some papers get duplicated</p>
</li>
<li><p>You don’t know if the other person is even ready</p>
</li>
</ul>
<p>This is what raw network communication would be like <strong>without TCP</strong>.</p>
<p>The internet needs a protocol that can:</p>
<ul>
<li><p>Confirm both sides are ready</p>
</li>
<li><p>Track what was sent</p>
</li>
<li><p>Detect what was lost</p>
</li>
<li><p>Fix problems automatically</p>
</li>
</ul>
<p>That protocol is TCP.</p>
<hr />
<h2 id="heading-what-is-tcp-and-why-it-is-needed">What is TCP and Why It Is Needed?</h2>
<p><strong>TCP (Transmission Control Protocol)</strong> is a transport-layer protocol that provides:</p>
<ul>
<li><p>Reliable delivery</p>
</li>
<li><p>Correct order of data</p>
</li>
<li><p>Error detection</p>
</li>
<li><p>Flow control</p>
</li>
<li><p>Connection management</p>
</li>
</ul>
<p>In simple words:</p>
<blockquote>
<p>TCP makes sure your data gets there — completely, correctly, and in order.</p>
</blockquote>
<p>This is why TCP is used for things like:</p>
<ul>
<li><p>Web browsing (HTTP/HTTPS)</p>
</li>
<li><p>File transfers</p>
</li>
<li><p>Emails</p>
</li>
<li><p>Secure logins</p>
</li>
</ul>
<hr />
<h2 id="heading-problems-tcp-is-designed-to-solve">Problems TCP Is Designed to Solve</h2>
<p>TCP exists to solve real network problems:</p>
<h3 id="heading-1-packet-loss">1. Packet Loss</h3>
<p>Some packets may disappear in the network.</p>
<p>➡️ TCP detects missing data and resends it.</p>
<hr />
<h3 id="heading-2-out-of-order-delivery">2. Out-of-Order Delivery</h3>
<p>Packets may arrive in a different order.</p>
<p>➡️ TCP reorders them correctly.</p>
<hr />
<h3 id="heading-3-duplicate-packets">3. Duplicate Packets</h3>
<p>The same packet may arrive twice.</p>
<p>➡️ TCP detects and ignores duplicates.</p>
<hr />
<h3 id="heading-4-unknown-connection-state">4. Unknown Connection State</h3>
<p>Sender doesn’t know if receiver is ready.</p>
<p>➡️ TCP establishes a connection before sending data.</p>
<hr />
<h2 id="heading-the-tcp-3-way-handshake">The TCP 3-Way Handshake</h2>
<p>Before any real data is sent, TCP first <strong>establishes a connection</strong> using a process called the <strong>3-way handshake</strong>.</p>
<p>This ensures:</p>
<ul>
<li><p>Both sides are reachable</p>
</li>
<li><p>Both sides are ready</p>
</li>
<li><p>Initial sequence numbers are agreed upon</p>
</li>
</ul>
<hr />
<h2 id="heading-simple-conversation-analogy">Simple Conversation Analogy</h2>
<p>Think of TCP like starting a phone call:</p>
<ol>
<li><p>Client: <em>“Can you hear me?”</em></p>
</li>
<li><p>Server: <em>“Yes, I can hear you. Can you hear me?”</em></p>
</li>
<li><p>Client: <em>“Yes, I can hear you.”</em></p>
</li>
</ol>
<p>Only after this does the real conversation begin.</p>
<hr />
<h2 id="heading-step-by-step-syn-syn-ack-ack">Step-by-Step: SYN, SYN-ACK, ACK</h2>
<p>Here’s how the real TCP handshake works:</p>
<h3 id="heading-step-1-syn-synchronize">Step 1 — SYN (Synchronize)</h3>
<p>Client → Server<br />Client sends a <strong>SYN</strong> packet.</p>
<p>Meaning:</p>
<blockquote>
<p>“I want to start a connection. Here is my starting sequence number.”</p>
</blockquote>
<hr />
<h3 id="heading-step-2-syn-ack-synchronize-acknowledge">Step 2 — SYN-ACK (Synchronize + Acknowledge)</h3>
<p>Server → Client<br />Server sends <strong>SYN-ACK</strong>.</p>
<p>Meaning:</p>
<blockquote>
<p>“I received your request. Here is my sequence number, and I acknowledge yours.”</p>
</blockquote>
<hr />
<h3 id="heading-step-3-ack-acknowledge">Step 3 — ACK (Acknowledge)</h3>
<p>Client → Server<br />Client sends <strong>ACK</strong>.</p>
<p>Meaning:</p>
<blockquote>
<p>“I acknowledge your sequence number. Connection is established.”</p>
</blockquote>
<hr />
<h3 id="heading-after-this">After This</h3>
<p>✅ TCP connection is now open<br />✅ Both sides are synchronized<br />✅ Data transfer can begin</p>
<hr />
<h2 id="heading-how-data-transfer-works-in-tcp">How Data Transfer Works in TCP</h2>
<p>Once connected, data is sent in small pieces called <strong>segments</strong>.</p>
<p>Each segment includes:</p>
<ul>
<li><p>Sequence number</p>
</li>
<li><p>Acknowledgement number</p>
</li>
<li><p>Data</p>
</li>
</ul>
<p>TCP uses these to track everything.</p>
<hr />
<h2 id="heading-sequence-numbers-high-level">Sequence Numbers (High Level)</h2>
<p>Every byte of data is numbered.</p>
<p>This allows TCP to:</p>
<ul>
<li><p>Know the correct order</p>
</li>
<li><p>Detect missing data</p>
</li>
<li><p>Detect duplicate data</p>
</li>
</ul>
<p>Think of it like page numbers in a book.</p>
<hr />
<h2 id="heading-acknowledgements-acks">Acknowledgements (ACKs)</h2>
<p>The receiver sends ACKs to say:</p>
<blockquote>
<p>“I have received data up to this point.”</p>
</blockquote>
<p>This tells the sender:</p>
<ul>
<li><p>What was received</p>
</li>
<li><p>What still needs to be sent</p>
</li>
</ul>
<hr />
<h2 id="heading-how-tcp-ensures-reliability-order-and-correctness">How TCP Ensures Reliability, Order, and Correctness</h2>
<p>TCP uses several mechanisms:</p>
<hr />
<h3 id="heading-1-acknowledgements">1. Acknowledgements</h3>
<p>Receiver confirms what it received.</p>
<p>➡️ If no ACK arrives, sender assumes data was lost.</p>
<hr />
<h3 id="heading-2-retransmission">2. Retransmission</h3>
<p>If data is lost:</p>
<p>➡️ TCP automatically resends it.</p>
<hr />
<h3 id="heading-3-sequence-numbers">3. Sequence Numbers</h3>
<p>Every piece of data is numbered.</p>
<p>➡️ TCP reorders out-of-order packets correctly.</p>
<hr />
<h3 id="heading-4-duplicate-detection">4. Duplicate Detection</h3>
<p>If a packet arrives twice:</p>
<p>➡️ TCP ignores the duplicate.</p>
<hr />
<h3 id="heading-5-flow-control">5. Flow Control</h3>
<p>TCP prevents a fast sender from overwhelming a slow receiver.</p>
<p>➡️ It controls how much data can be “in flight.”</p>
<hr />
<h2 id="heading-packet-loss-and-retransmission-concept">Packet Loss and Retransmission (Concept)</h2>
<p>If this happens:</p>
<pre><code class="lang-plaintext">Sender → Packet 1
Sender → Packet 2   ❌ LOST
Sender → Packet 3
</code></pre>
<p>Receiver sees:</p>
<ul>
<li><p>Packet 1</p>
</li>
<li><p>Packet 3 (gap detected)</p>
</li>
</ul>
<p>TCP realizes Packet 2 is missing.</p>
<p>➡️ Sender retransmits Packet 2<br />➡️ Order is restored</p>
<hr />
<h2 id="heading-how-a-tcp-connection-is-closed">How a TCP Connection Is Closed</h2>
<p>TCP doesn’t just stop suddenly. It closes the connection gracefully.</p>
<p>This is done using <strong>FIN</strong> and <strong>ACK</strong> messages.</p>
<hr />
<h2 id="heading-simple-closing-analogy">Simple Closing Analogy</h2>
<p>Like ending a phone call:</p>
<ol>
<li><p>“I’m done talking.”</p>
</li>
<li><p>“Okay, I acknowledge.”</p>
</li>
<li><p>“I’m also done.”</p>
</li>
<li><p>“Okay, acknowledged.”</p>
</li>
</ol>
<hr />
<h2 id="heading-tcp-connection-termination-high-level">TCP Connection Termination (High Level)</h2>
<h3 id="heading-step-1-fin">Step 1 — FIN</h3>
<p>One side sends <strong>FIN</strong>.</p>
<p>Meaning:</p>
<blockquote>
<p>“I have no more data to send.”</p>
</blockquote>
<hr />
<h3 id="heading-step-2-ack">Step 2 — ACK</h3>
<p>Other side sends <strong>ACK</strong>.</p>
<p>Meaning:</p>
<blockquote>
<p>“I acknowledge. You can stop sending.”</p>
</blockquote>
<hr />
<h3 id="heading-step-3-fin-other-side">Step 3 — FIN (Other Side)</h3>
<p>Other side sends its own <strong>FIN</strong>.</p>
<p>Meaning:</p>
<blockquote>
<p>“I’m also done.”</p>
</blockquote>
<hr />
<h3 id="heading-step-4-final-ack">Step 4 — Final ACK</h3>
<p>First side sends final <strong>ACK</strong>.</p>
<p>➡️ Connection is fully closed.</p>
<hr />
<h2 id="heading-tcp-connection-lifecycle">TCP Connection Lifecycle</h2>
<p>You can think of TCP like this:</p>
<pre><code class="lang-plaintext">1. Establish Connection (3-way handshake)
2. Transfer Data (reliable, ordered)
3. Close Connection (FIN/ACK)
</code></pre>
<hr />
<h2 id="heading-diagram-ideas-for-your-blog">Diagram Ideas for Your Blog</h2>
<h3 id="heading-1-tcp-3-way-handshake">1. TCP 3-Way Handshake</h3>
<pre><code class="lang-plaintext">Client → SYN → Server
Client ← SYN-ACK ← Server
Client → ACK → Server
</code></pre>
<hr />
<h3 id="heading-2-data-transfer-with-acks">2. Data Transfer with ACKs</h3>
<pre><code class="lang-plaintext">Seq 1 → 
       ← ACK 1
Seq 2 → 
       ← ACK 2
</code></pre>
<hr />
<h3 id="heading-3-packet-loss-amp-retransmission">3. Packet Loss &amp; Retransmission</h3>
<pre><code class="lang-plaintext">Seq 2 → ❌ Lost
Receiver notices gap
Sender retransmits Seq 2
</code></pre>
<hr />
<h3 id="heading-4-tcp-lifecycle">4. TCP Lifecycle</h3>
<pre><code class="lang-plaintext">ESTABLISH → TRANSFER → CLOSE
</code></pre>
<hr />
<p>Credit: Chatgpt</p>
]]></content:encoded></item><item><title><![CDATA[TCP vs UDP: When to Use What, and How TCP Relates to HTTP]]></title><description><![CDATA[Learn the differences between TCP and UDP protocols, when to use them, and how TCP relates to HTTP for reliable data transmission]]></description><link>https://chaiaurcode-assignments.hashnode.dev/tcp-vs-udp-when-to-use-what-and-how-tcp-relates-to-http</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/tcp-vs-udp-when-to-use-what-and-how-tcp-relates-to-http</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sun, 01 Feb 2026 13:57:21 GMT</pubDate><content:encoded><![CDATA[<h2 id="heading-the-big-idea-the-internet-needs-rules">The Big Idea: The Internet Needs Rules</h2>
<p>Imagine sending a package to a friend.</p>
<p>Without rules:</p>
<ul>
<li><p>The package might get lost</p>
</li>
<li><p>Arrive in the wrong order</p>
</li>
<li><p>Arrive damaged</p>
</li>
<li><p>Or not arrive at all</p>
</li>
</ul>
<p>The internet is the same. When computers send data, they need <strong>rules (protocols)</strong> to decide:</p>
<ul>
<li><p>How to send data</p>
</li>
<li><p>How to receive it</p>
</li>
<li><p>How to handle errors</p>
</li>
<li><p>How to make sure it arrives correctly</p>
</li>
</ul>
<p>That’s where <strong>TCP, UDP, and HTTP</strong> come in.</p>
<hr />
<h2 id="heading-what-is-tcp-transmission-control-protocol">What is TCP? (Transmission Control Protocol)</h2>
<h3 id="heading-tcp-safe-and-reliable">TCP = Safe and Reliable</h3>
<p>Think of TCP like sending a <strong>courier package with tracking and signature required</strong>.</p>
<p>TCP makes sure:</p>
<p>✅ Data arrives<br />✅ Data arrives in the correct order<br />✅ Missing data is re-sent<br />✅ Both sides agree when communication starts and ends</p>
<h3 id="heading-simple-analogy">Simple Analogy</h3>
<p>📦 <strong>TCP is like:</strong></p>
<blockquote>
<p>A courier service that tracks your package, resends it if lost, and makes sure it’s delivered in order.</p>
</blockquote>
<h3 id="heading-what-tcp-cares-about">What TCP Cares About</h3>
<ul>
<li><p>Reliability</p>
</li>
<li><p>Accuracy</p>
</li>
<li><p>Order</p>
</li>
<li><p>Error correction</p>
</li>
</ul>
<p>This makes TCP slightly slower — but very trustworthy.</p>
<hr />
<h2 id="heading-what-is-udp-user-datagram-protocol">What is UDP? (User Datagram Protocol)</h2>
<h3 id="heading-udp-fast-but-risky">UDP = Fast but Risky</h3>
<p>Think of UDP like making a <strong>public announcement on a loudspeaker</strong>.</p>
<p>You send the message, but:</p>
<p>❌ No guarantee it’s received<br />❌ No guarantee of order<br />❌ No resending if lost<br />❌ No confirmation</p>
<h3 id="heading-simple-analogy-1">Simple Analogy</h3>
<p>📢 <strong>UDP is like:</strong></p>
<blockquote>
<p>Shouting a message in a crowd — fast, but you don’t know who heard it.</p>
</blockquote>
<h3 id="heading-what-udp-cares-about">What UDP Cares About</h3>
<ul>
<li><p>Speed</p>
</li>
<li><p>Low delay</p>
</li>
<li><p>Minimal overhead</p>
</li>
</ul>
<p>UDP is faster because it doesn’t do checking, tracking, or resending.</p>
<hr />
<h2 id="heading-key-differences-between-tcp-and-udp">Key Differences Between TCP and UDP</h2>
<div class="hn-table">
<table>
<thead>
<tr>
<td>Feature</td><td>TCP 🛡️ (Reliable)</td><td>UDP ⚡ (Fast)</td></tr>
</thead>
<tbody>
<tr>
<td>Reliable delivery</td><td>Yes</td><td>No</td></tr>
<tr>
<td>Correct order</td><td>Yes</td><td>No</td></tr>
<tr>
<td>Error correction</td><td>Yes</td><td>No</td></tr>
<tr>
<td>Speed</td><td>Slower</td><td>Faster</td></tr>
<tr>
<td>Overhead</td><td>Higher</td><td>Lower</td></tr>
<tr>
<td>Use case focus</td><td>Accuracy</td><td>Speed</td></tr>
</tbody>
</table>
</div><hr />
<h2 id="heading-when-to-use-tcp">When to Use TCP</h2>
<p>Use TCP when <strong>correctness matters more than speed</strong>.</p>
<p>Examples:</p>
<ul>
<li><p>🌐 Web browsing (HTTP/HTTPS)</p>
</li>
<li><p>📧 Email (SMTP, IMAP, POP3)</p>
</li>
<li><p>📁 File downloads/uploads</p>
</li>
<li><p>🔐 Secure communication</p>
</li>
</ul>
<p>If data is missing or wrong, it’s a big problem — so TCP is used.</p>
<hr />
<h2 id="heading-when-to-use-udp">When to Use UDP</h2>
<p>Use UDP when <strong>speed matters more than perfection</strong>.</p>
<p>Examples:</p>
<ul>
<li><p>🎮 Online gaming</p>
</li>
<li><p>📞 Voice calls (VoIP)</p>
</li>
<li><p>📺 Live video streaming</p>
</li>
<li><p>🛰️ DNS lookups</p>
</li>
</ul>
<p>If a packet is lost, it’s better to move on than wait.</p>
<p>For example:</p>
<ul>
<li>In a video call, a tiny glitch is better than freezing the call.</li>
</ul>
<hr />
<h2 id="heading-real-world-examples">Real-World Examples</h2>
<h3 id="heading-tcp-examples-reliable">TCP Examples (Reliable)</h3>
<ul>
<li><p>Loading a website</p>
</li>
<li><p>Downloading a PDF</p>
</li>
<li><p>Sending an email</p>
</li>
<li><p>Logging into a bank website</p>
</li>
</ul>
<h3 id="heading-udp-examples-fast">UDP Examples (Fast)</h3>
<ul>
<li><p>Zoom / Google Meet calls</p>
</li>
<li><p>Online multiplayer games</p>
</li>
<li><p>Live sports streaming</p>
</li>
<li><p>Voice chat in games</p>
</li>
</ul>
<hr />
<h2 id="heading-what-is-http">What is HTTP?</h2>
<h3 id="heading-http-rules-for-talking-about-web-data">HTTP = Rules for Talking About Web Data</h3>
<p>HTTP stands for <strong>HyperText Transfer Protocol</strong>.</p>
<p>HTTP defines:</p>
<ul>
<li><p>How a browser asks for a web page</p>
</li>
<li><p>How a server sends a response</p>
</li>
<li><p>What a request looks like</p>
</li>
<li><p>What a response looks like</p>
</li>
</ul>
<h3 id="heading-important-point">Important Point:</h3>
<blockquote>
<p><strong>HTTP is NOT responsible for delivering the data safely.</strong></p>
</blockquote>
<p>That’s not its job.</p>
<p>HTTP just defines <strong>what to say</strong>, not <strong>how to deliver it safely</strong>.</p>
<hr />
<h2 id="heading-where-http-fits-layering-concept">Where HTTP Fits (Layering Concept)</h2>
<p>Think in layers:</p>
<pre><code class="lang-plaintext">HTTP  → What to say (web rules)
TCP   → How to safely deliver it
IP    → How to find the destination
</code></pre>
<p>So:</p>
<ul>
<li><p>HTTP = Application-level protocol</p>
</li>
<li><p>TCP = Transport-level protocol</p>
</li>
</ul>
<hr />
<h2 id="heading-relationship-between-http-and-tcp">Relationship Between HTTP and TCP</h2>
<h3 id="heading-http-runs-on-top-of-tcp">HTTP Runs on Top of TCP</h3>
<p>When you open a website:</p>
<ol>
<li><p>Browser creates a TCP connection to the server</p>
</li>
<li><p>HTTP request is sent over that TCP connection</p>
</li>
<li><p>Server sends HTTP response back over TCP</p>
</li>
<li><p>TCP makes sure everything arrives correctly</p>
</li>
</ol>
<h3 id="heading-simple-flow">Simple Flow</h3>
<pre><code class="lang-plaintext">Browser
  ↓ (HTTP Request)
TCP Connection
  ↓
Internet
  ↓
Server
</code></pre>
<hr />
<h2 id="heading-why-http-does-not-replace-tcp">Why HTTP Does NOT Replace TCP</h2>
<p>This is a very common beginner confusion.</p>
<p>❌ HTTP is NOT the same as TCP<br />❌ HTTP does NOT replace TCP</p>
<p>Because:</p>
<ul>
<li><p>HTTP defines <strong>message format and meaning</strong></p>
</li>
<li><p>TCP handles <strong>delivery, order, and reliability</strong></p>
</li>
</ul>
<p>They solve different problems.</p>
<h3 id="heading-simple-analogy-2">Simple Analogy</h3>
<p>📝 HTTP = The letter you write<br />📦 TCP = The courier that delivers it safely</p>
<p>You need both.</p>
<hr />
<h2 id="heading-common-beginner-confusion">Common Beginner Confusion</h2>
<h3 id="heading-is-http-the-same-as-tcp">❓ “Is HTTP the same as TCP?”</h3>
<p>❌ No.</p>
<ul>
<li><p>HTTP = Web communication rules</p>
</li>
<li><p>TCP = Reliable data transport</p>
</li>
</ul>
<h3 id="heading-can-http-work-without-tcp">❓ “Can HTTP work without TCP?”</h3>
<p>Traditionally: No.<br />HTTP normally runs on TCP.</p>
<p>(Advanced note: HTTP/3 uses QUIC over UDP — but beginners can ignore this for now.)</p>
<hr />
<h2 id="heading-simple-diagram-ideas-for-your-blog">Simple Diagram Ideas (for your blog)</h2>
<h3 id="heading-1-tcp-vs-udp-flow">1. TCP vs UDP Flow</h3>
<pre><code class="lang-plaintext">TCP:
Sender ⇄ Receiver
✔ Acknowledge
✔ Resend if lost
✔ Ordered

UDP:
Sender → Receiver
✘ No acknowledge
✘ No resend
✘ No order
</code></pre>
<hr />
<h3 id="heading-2-simplified-internet-layers">2. Simplified Internet Layers</h3>
<pre><code class="lang-plaintext">Application:  HTTP
Transport:    TCP / UDP
Network:      IP
</code></pre>
<hr />
<h3 id="heading-3-http-over-tcp">3. HTTP Over TCP</h3>
<pre><code class="lang-plaintext">HTTP Request
    ↓
   TCP
    ↓
 Internet
    ↓
 Server
</code></pre>
<hr />
<p>Credit: Chatgpt</p>
]]></content:encoded></item><item><title><![CDATA[Getting Started with CURL]]></title><description><![CDATA[Learn how to communicate with servers using cURL, a powerful tool for testing APIs, debugging, and automating server requests from your terminal]]></description><link>https://chaiaurcode-assignments.hashnode.dev/getting-started-with-curl</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/getting-started-with-curl</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><category><![CDATA[curl]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sat, 31 Jan 2026 14:29:54 GMT</pubDate><content:encoded><![CDATA[<h2 id="heading-1-what-is-a-server-and-why-do-we-need-to-talk-to-it">1. What is a Server (and Why Do We Need to Talk to It?)</h2>
<h3 id="heading-what-is-a-server">What is a server?</h3>
<p>A <strong>server</strong> is just a computer on the internet that:</p>
<ul>
<li><p>Stores data</p>
</li>
<li><p>Runs applications</p>
</li>
<li><p>Responds to requests from other computers (clients)</p>
</li>
</ul>
<p>Examples of servers:</p>
<ul>
<li><p>Google’s servers</p>
</li>
<li><p>YouTube’s servers</p>
</li>
<li><p>Your college portal server</p>
</li>
<li><p>A backend server you build using Spring Boot, Node.js, etc.</p>
</li>
</ul>
<h3 id="heading-why-do-we-need-to-talk-to-a-server">Why do we need to talk to a server?</h3>
<p>Whenever you:</p>
<ul>
<li><p>Open a website</p>
</li>
<li><p>Log in to an app</p>
</li>
<li><p>Fetch user data</p>
</li>
<li><p>Submit a form</p>
</li>
<li><p>Call an API</p>
</li>
</ul>
<p>👉 Your computer is <strong>sending a request</strong> to a server<br />👉 The server <strong>sends back a response</strong></p>
<p>This request–response cycle is the heart of the web.</p>
<hr />
<h2 id="heading-2-how-do-we-normally-talk-to-servers">2. How Do We Normally Talk to Servers?</h2>
<p>Most people use a <strong>browser</strong>:</p>
<pre><code class="lang-plaintext">You → Browser → Server → Browser → You
</code></pre>
<p>You type a URL, the browser sends a request, and shows you the response nicely.</p>
<p>But programmers often need to:</p>
<ul>
<li><p>Test APIs</p>
</li>
<li><p>Debug backend servers</p>
</li>
<li><p>Send custom requests</p>
</li>
<li><p>Automate calls</p>
</li>
<li><p>Work without a browser</p>
</li>
</ul>
<p>That’s where <strong>cURL</strong> comes in.</p>
<hr />
<h2 id="heading-3-what-is-curl-in-very-simple-terms">3. What is cURL (in Very Simple Terms)</h2>
<h3 id="heading-simple-definition">Simple definition:</h3>
<blockquote>
<p><strong>cURL is a tool that lets you send requests to servers from the terminal.</strong></p>
</blockquote>
<p>Think of cURL as:</p>
<ul>
<li><p>A mini-browser for programmers</p>
</li>
<li><p>A way to “talk to servers” using commands</p>
</li>
</ul>
<p>Instead of clicking buttons, you type commands.</p>
<h3 id="heading-conceptually">Conceptually:</h3>
<pre><code class="lang-plaintext">cURL → Server → Response (shown in terminal)
</code></pre>
<hr />
<h2 id="heading-4-why-programmers-need-curl">4. Why Programmers Need cURL</h2>
<p>Programmers use cURL to:</p>
<p>✅ Test backend APIs<br />✅ Check if a server is working<br />✅ Debug request/response issues<br />✅ Send data to servers<br />✅ Automate API calls in scripts<br />✅ Work without any UI</p>
<p>If you are learning:</p>
<ul>
<li><p>Backend</p>
</li>
<li><p>APIs</p>
</li>
<li><p>DevOps</p>
</li>
<li><p>Cloud</p>
</li>
<li><p>Microservices</p>
</li>
</ul>
<p>👉 cURL is a must-know basic tool.</p>
<hr />
<h2 id="heading-5-making-your-first-curl-request-simplest-possible">5. Making Your First cURL Request (Simplest Possible)</h2>
<p>Let’s fetch a webpage.</p>
<h3 id="heading-command">Command:</h3>
<pre><code class="lang-plaintext">curl https://example.com
</code></pre>
<p>That’s it. No flags. No complexity.</p>
<h3 id="heading-what-happens">What happens?</h3>
<ul>
<li><p>cURL sends a request to <a target="_blank" href="http://example.com">example.com</a></p>
</li>
<li><p>The server sends back HTML</p>
</li>
<li><p>cURL prints it in your terminal</p>
</li>
</ul>
<p>You will see a bunch of HTML text.</p>
<p>This proves:<br />✅ Your terminal just talked to a server<br />✅ You received a response</p>
<hr />
<h2 id="heading-6-understanding-request-and-response-conceptually">6. Understanding Request and Response (Conceptually)</h2>
<p>Every web interaction has two parts:</p>
<h3 id="heading-request-from-you-to-server">Request (from you to server)</h3>
<p>Contains:</p>
<ul>
<li><p>URL</p>
</li>
<li><p>Method (GET, POST, etc.)</p>
</li>
<li><p>Headers</p>
</li>
<li><p>Optional data</p>
</li>
</ul>
<h3 id="heading-response-from-server-to-you">Response (from server to you)</h3>
<p>Contains:</p>
<ul>
<li><p>Status code</p>
</li>
<li><p>Headers</p>
</li>
<li><p>Data (HTML, JSON, etc.)</p>
</li>
</ul>
<h3 id="heading-simple-flow-diagram">Simple flow diagram:</h3>
<pre><code class="lang-plaintext">Request
You (cURL) ─────────▶ Server

Response
You (cURL) ◀───────── Server
</code></pre>
<hr />
<h2 id="heading-7-understanding-the-response-status-data">7. Understanding the Response (Status + Data)</h2>
<p>Let’s see the response more clearly.</p>
<h3 id="heading-command-1">Command:</h3>
<pre><code class="lang-plaintext">curl -i https://example.com
</code></pre>
<p>This shows:</p>
<ul>
<li><p>Status line</p>
</li>
<li><p>Headers</p>
</li>
<li><p>Body (data)</p>
</li>
</ul>
<p>You may see something like:</p>
<pre><code class="lang-plaintext">HTTP/1.1 200 OK
Content-Type: text/html
...

&lt;html&gt;
  ...
&lt;/html&gt;
</code></pre>
<h3 id="heading-important-parts">Important parts:</h3>
<h4 id="heading-status-code">Status Code</h4>
<ul>
<li><p><code>200 OK</code> → Success</p>
</li>
<li><p><code>404 Not Found</code> → Resource not found</p>
</li>
<li><p><code>500 Internal Server Error</code> → Server problem</p>
</li>
</ul>
<h4 id="heading-data-body">Data (Body)</h4>
<p>This is the actual content:</p>
<ul>
<li><p>HTML</p>
</li>
<li><p>JSON</p>
</li>
<li><p>Text</p>
</li>
<li><p>etc.</p>
</li>
</ul>
<hr />
<h2 id="heading-8-introducing-get-and-post-only-the-basics">8. Introducing GET and POST (Only the Basics)</h2>
<h3 id="heading-get-getting-data">GET — Getting data</h3>
<p>Used to:</p>
<ul>
<li><p>Fetch data</p>
</li>
<li><p>Read information</p>
</li>
</ul>
<p>Example:</p>
<pre><code class="lang-plaintext">curl https://api.example.com/users
</code></pre>
<p>Meaning:</p>
<blockquote>
<p>“Server, give me users data.”</p>
</blockquote>
<hr />
<h3 id="heading-post-sending-data">POST — Sending data</h3>
<p>Used to:</p>
<ul>
<li><p>Send data</p>
</li>
<li><p>Create something</p>
</li>
<li><p>Submit forms</p>
</li>
</ul>
<p>Example (conceptual):</p>
<pre><code class="lang-plaintext">curl -X POST https://api.example.com/users
</code></pre>
<p>Meaning:</p>
<blockquote>
<p>“Server, I want to send data to you.”</p>
</blockquote>
<p>(We keep it simple for now — data and headers come later.)</p>
<hr />
<h2 id="heading-9-using-curl-to-talk-to-apis">9. Using cURL to Talk to APIs</h2>
<p>APIs are just servers that return <strong>data instead of web pages</strong>.</p>
<p>Instead of HTML, you get JSON.</p>
<p>Example:</p>
<pre><code class="lang-plaintext">curl https://api.github.com
</code></pre>
<p>You will see JSON output.</p>
<p>This is extremely useful for:</p>
<ul>
<li><p>Testing backend endpoints</p>
</li>
<li><p>Checking API responses</p>
</li>
<li><p>Debugging server logic</p>
</li>
</ul>
<hr />
<h2 id="heading-10-browser-vs-curl-conceptual-difference">10. Browser vs cURL (Conceptual Difference)</h2>
<h3 id="heading-browser">Browser:</h3>
<ul>
<li><p>Designed for humans</p>
</li>
<li><p>Renders HTML</p>
</li>
<li><p>Has UI</p>
</li>
<li><p>Hides technical details</p>
</li>
</ul>
<h3 id="heading-curl">cURL:</h3>
<ul>
<li><p>Designed for programmers</p>
</li>
<li><p>Shows raw data</p>
</li>
<li><p>No UI</p>
</li>
<li><p>Shows real request/response</p>
</li>
</ul>
<p>This makes cURL perfect for backend development.</p>
<hr />
<h2 id="heading-11-where-curl-fits-in-backend-development">11. Where cURL Fits in Backend Development</h2>
<p>In backend work, you often:</p>
<ul>
<li><p>Build REST APIs</p>
</li>
<li><p>Test endpoints</p>
</li>
<li><p>Debug errors</p>
</li>
<li><p>Check server health</p>
</li>
</ul>
<p>Typical workflow:</p>
<pre><code class="lang-plaintext">Build Backend → Use cURL to test → Fix bugs → Repeat
</code></pre>
<p>cURL becomes your <strong>first debugging tool</strong>.</p>
<hr />
<h2 id="heading-12-common-beginner-mistakes-with-curl">12. Common Beginner Mistakes with cURL</h2>
<p>Here are very common mistakes:</p>
<p>❌ Thinking cURL is only for downloading websites<br />❌ Getting scared by too many flags<br />❌ Not understanding what status codes mean<br />❌ Copy-pasting complex commands without understanding<br />❌ Not realizing cURL is just sending HTTP requests</p>
<p>Best approach:<br />👉 Start simple<br />👉 Focus on concepts, not flags<br />👉 Understand request and response first</p>
<hr />
<h2 id="heading-13-simple-mental-model-very-important">13. Simple Mental Model (Very Important)</h2>
<p>Always think like this:</p>
<pre><code class="lang-plaintext">cURL = Tool to send HTTP requests
Server = Machine that responds
Response = Status + Data
</code></pre>
<p>If you understand this, everything else becomes easier.</p>
<hr />
<h2 id="heading-14-summary">14. Summary</h2>
<ul>
<li><p>A server is a computer that responds to requests</p>
</li>
<li><p>Browsers and cURL both talk to servers</p>
</li>
<li><p>cURL lets programmers send requests from terminal</p>
</li>
<li><p>cURL is essential for backend and API testing</p>
</li>
<li><p>Start with simple GET requests</p>
</li>
<li><p>Focus on understanding request and response</p>
</li>
</ul>
<p>Credits: Chatgpt</p>
]]></content:encoded></item><item><title><![CDATA[How DNS Resolution Works]]></title><description><![CDATA[Learn how DNS resolution works, from the browser request to obtaining an IP address using Recursive and Authoritative DNS servers]]></description><link>https://chaiaurcode-assignments.hashnode.dev/how-dns-resolution-works</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/how-dns-resolution-works</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><category><![CDATA[dns]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Fri, 30 Jan 2026 08:46:42 GMT</pubDate><content:encoded><![CDATA[<p>When we hit a request to a website, several operations are performed within a fraction of second. In this article, we are going to see how a browser handles the request specifically.</p>
<p>So when the browser receives a request, the request is handed over to a structure called as Recursive DNS resolver. This DNS resolver processes the request with the DNS servers and system, and provide us a IP at the end. Now let’s discuss about the DNS system broadly.</p>
<h2 id="heading-dns">DNS</h2>
<p>DNS stands for Domain Name System. In simple terms, it is the phone-book of the internet. It processes the human readable language into the IPs of different website.</p>
<p>It is because we humans are not capable of remembering thousands of random combination of numbers, rather we humans are better are remembering names.</p>
<p>Mainly, there are 13 DNS root servers all over the world.</p>
<p>If we move further, it is seen that, the DNS doesn’t provide us the IP directly, rather it gives us a address and tells us to move ahead. It can be represented in such a way that: <em>“DNS tells us whom we should talk next”</em>. The address it gives us is called as the: TLD(Top Level Domain)</p>
<p>TLD(Top Level Domain): A Top-Level Domain (TLD) is the final segment of a domain name, located after the last dot. Example: ‘.com', '.org'</p>
<p>Then the TLD gives us another address to where we should head to called as the authoritative DNS servers.</p>
<p>Authoritative DNS servers: These servers contain all the information regarding the DNS servers, which means this is the place where we will be finding the IP of the website we are looking for.</p>
<p>Now this IP is returned to the recursive DNS resolver, and the resolver handles that IP to the browser.</p>
<p><img src="https://miro.medium.com/v2/resize:fit:1400/1*YVjZCxaKihEe4jSl1bMshQ.png" alt="he Complete Journey of a Web Request: DNS, TCP, HTTPS | Medium" class="image--center mx-auto" /></p>
<h2 id="heading-dig-command">Dig command</h2>
<p>Dig stands for: Domain Information Groper</p>
<p>It’s a simple command used by developers to get information about the DNS servers on the terminal. The dig command’s variations can be also used to point out some issues(if there) of the DNS.</p>
<p>Some of the basic dig commands are:</p>
<p><code>dig . NS</code> : It lists all the 13 DNS root servers.</p>
<p><code>dig com NS</code> : It gives us all the authoritative servers that have the TLDs as “<em>.com</em>”</p>
<p><code>dig google.com NS</code> : It gives us all the authoritative server names regarding to “<em>google.com”</em></p>
<p><code>dig google.com</code> : This command by default returns the IP of that domain, if no other records are specified.</p>
]]></content:encoded></item><item><title><![CDATA[DNS Record Types Explained]]></title><description><![CDATA[Learn about DNS record types including A, AAAA, CNAME, MX, NS, and TXT, and their roles in web domain management]]></description><link>https://chaiaurcode-assignments.hashnode.dev/dns-record-types-explained</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/dns-record-types-explained</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[dns]]></category><category><![CDATA[server]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Tue, 27 Jan 2026 16:16:04 GMT</pubDate><content:encoded><![CDATA[<p>DNS stands for domain name system.</p>
<p>When a person hits a request to a website, the browser takes that request and hands it over to the DNS resolver. The DNS resolver do all the processes to obtain the IP of the website that the person had requested. Within those processes, the IP is mainly obtained through the authoritative DNS server. This authoritative DNS server contains all the information regarding a website. The information here is stored in different folders called as DNS records or zone files. There are several types of DNS records storing specific data of a website. In this article we are going to discuss some of the important DNS record types.</p>
<h2 id="heading-a">A</h2>
<p>A record accepts the domain name, and returns the IP of that domain name in IP version 4 format.</p>
<p>Example of how a <em>A record</em> store data: <code>example.com. A 192.0.2.1 (TTL: 14400)</code></p>
<h2 id="heading-aaaa">AAAA</h2>
<p>AAAA record type is similar to A record type. It also accepts the domain name, and return the IP of that domain but in a IP version 6 format.</p>
<p>Example of a IPv6: <code>2001:db8:85a3:0:0:8a2e:370:7334</code> </p>
<h2 id="heading-cname">CNAME</h2>
<p>CNAME stands for <em>canonical name</em>. As the name suggest, this record stores the most relevant alias names of an website. Which means, if a user search for some alias name of an website, it will end up at a single IP that is relevant to the alias name of that domain name.</p>
<p>Example:</p>
<p>Person A searches for <em>Google</em></p>
<p>Person B searches for <em>google.com</em></p>
<p>Person C searches for <em>www.google.com</em></p>
<p>All the three person are going to end up on the website: <em>www.google.com</em></p>
<h2 id="heading-mx">MX</h2>
<p>MX stands for <em>mail exchange</em>. This record validates the incoming mail requests and verifies it through the mail server and then further processes it.</p>
<h2 id="heading-ns">NS</h2>
<p>This record keeps all the information about the DNS server itself. It tracks the incoming request and to which DNS server it is heading for, all the information are stored here.</p>
<h2 id="heading-txt">TXT</h2>
<p>This record stores a text provided by the domain owner for security purposes. Suppose just in case, you need to proof to an external party that this domain belongs to you, you can show up the text that you would have stored in this record. In this way you can verify that the corresponding domain belongs to us.</p>
]]></content:encoded></item><item><title><![CDATA[Understanding Network Devices]]></title><description><![CDATA[Explore network devices like modems, routers, hubs, switches, firewalls, and load balancers to understand their roles in real-world scenarios]]></description><link>https://chaiaurcode-assignments.hashnode.dev/understanding-network-devices</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/understanding-network-devices</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[ChaiCohort]]></category><category><![CDATA[networking]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Tue, 27 Jan 2026 07:39:15 GMT</pubDate><content:encoded><![CDATA[<p>In this article we are going to discuss about some networking devices and and their usage in the real world scenarios.</p>
<h2 id="heading-modem">Modem</h2>
<p>A modem is a device which is installed between the computer system and the internet source. The internet source is placed somewhere on Earth but very far away from our home. The connections are brought to us using wires called as cables. The internet which is passed through the cables are in the form of analog signals. But the thing is, our computer system only accepts digital signals. So, to solve this problem modems are used. Modem converts(modulates) the incoming analog signal to digital signal and converts(de-modulates) the outgoing digital signal into the analog signal. This is why, modem is also called as modulator and de-modulator.</p>
<p><img src="https://media.geeksforgeeks.org/wp-content/uploads/20230826113414/Modembak.png" alt="What is Modem? - GeeksforGeeks" class="image--center mx-auto" /></p>
<h2 id="heading-router">Router</h2>
<p>Modem provides us the required internet, but the problem is it can only provide internet to a single device or equipment. To solve this problem, routers are used. Routers are used to enroute the internet signals into different devices, both wire or wireless. By the help of it, multiple devices can get the access to internet from a single internet source.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1769496506094/9a716fff-0d93-41d5-a79e-b5b9287d1771.png" alt class="image--center mx-auto" /></p>
<h2 id="heading-hub">Hub</h2>
<p>Hubs are used to share data or information from one device to all other devices in a local area network(LAN).</p>
<p><img src="https://images.ctfassets.net/aoyx73g9h2pg/2BeY1nsgq7F1zV7TZezCeV/a01a704bbe01389eebedccdfe285801b/What-is-a-Computer-Network-Hub-Diagram.jpg" alt="What is a Computer Network Hub?" class="image--center mx-auto" /></p>
<p>One of the major disadvantages in a hub is that, the data sent from one device is received by all the other devices in that LAN. This can compromise the data security and is not a preferrable option. To solve this issue, switches are created.</p>
<h2 id="heading-switch">Switch</h2>
<p>Switch is also similar to hub but with a major advancement. Switches are used to share data or information from one device to another device in LAN, but with the use of IP addresses. This gives us data integrity and the information sent is only received by the user, it was intended for.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1769499732036/65260073-0491-4ba4-8e8a-4db0a1fc8de6.png" alt class="image--center mx-auto" /></p>
<h2 id="heading-firewall">Firewall</h2>
<p>The use of firewall is to protect a device from the incoming malwares or virus attacks done by the hackers or some other entities. It acts as a bodyguard of the software of our system and only allows the safe and required data that our system had requested.</p>
<p><img src="https://cdn.prod.website-files.com/5ff66329429d880392f6cba2/617b8f940ca40dec2fadc059_What%20is%20a%20firewall.png" alt="What is Firewall? Definition, Meaning, Examples" class="image--center mx-auto" /></p>
<h2 id="heading-load-balancers">Load Balancers</h2>
<p>If we send a request to a website on the web, then the website hits a request on their respective server, and then the server processes the request and send the response back to the user’s IP. This is the general overall flow of the client-server architecture.</p>
<p>Now let’s take a scenario in which a number of user requests are hitting on the server. This will obviously cause server overload, and it may lead to the crash of the server. To avoid these situations load balancers are installed so that it will manage the incoming requests and evenly distribute them to different servers of the organization to prevent crashing. In this way, all the users will get their respective responses without causing any extra load to the specifics servers of the organization.</p>
<p><img src="https://media.geeksforgeeks.org/wp-content/uploads/20260112182015615865/load_balancer.webp" alt="Introduction to Load Balancer - GeeksforGeeks" class="image--center mx-auto" /></p>
]]></content:encoded></item><item><title><![CDATA[Inside Git: How It Works and the Role of the .git Folder]]></title><description><![CDATA[Explore the inner workings of Git's .git folder, including HEAD, refs, and objects, and understand their role in tracking changes]]></description><link>https://chaiaurcode-assignments.hashnode.dev/inside-git-how-it-works-and-the-role-of-the-git-folder</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/inside-git-how-it-works-and-the-role-of-the-git-folder</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[GitHub]]></category><category><![CDATA[Git]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Mon, 26 Jan 2026 16:17:15 GMT</pubDate><content:encoded><![CDATA[<p>When we initialize a folder with the command <code>git init</code> , then git adds a special folder named as <em>.git</em> to the corresponding folder to track the changes of that file/folder.</p>
<p>If we sneak into the <em>.git</em> folder, then we will be able to see many sub folders within that folder. Some of the important sub folders are: HEAD, refs, objects</p>
<p>There are many other sub folders including the above, but we will be discussing the above three in this article.</p>
<h2 id="heading-head">HEAD</h2>
<p>If we try to read the HEAD folder using the command <code>cat HEAD</code>, we should see the content inside the HEAD which should give some output like <em>Main</em>. This <em>Main</em> is the name of the head branch of the git repository.</p>
<p>So, the HEAD folder stores the information of the node where the head pointer is pointing at.</p>
<p>Before moving ahead, let us discuss about branches in git.</p>
<hr />
<h3 id="heading-branches">BRANCHES</h3>
<p>Let’s imagine there are two person X and Y working on a single project. At some point X and Y can’t continue to code together because some conflict arises in the code base as they are working on two different features. This is the point where the branching feature of git can step in and help them to solve this problem. Branching in git is a process in which different branches are created. These branches are nothing but a separate space which is completely different from the main code base. Developers can create multiple branches and work on various features or bugs, and at last they can merge this branch into the main branch whenever their work is completed.</p>
<p><img src="https://i0.wp.com/miro.medium.com/max/1166/1*vokGvT8u0jgPO6G4tjKe4A.png?w=800&amp;ssl=1" alt="A review of Git branching strategies - LEARNCSDESIGN" class="image--center mx-auto" /></p>
<hr />
<h2 id="heading-refs">refs</h2>
<p>This folder contains a sub folder named as <em>heads</em>. Further this <em>heads</em> contains the name of the node where the actual head of the repository is pointing at. At last, when you try to read this head node inside the <em>heads</em> using the <code>cat node</code> command, it will give us the hash of the head node or commit.</p>
<p>Hash: Its a unique mixture of alphanumeric characters, which helps to identify a commit.</p>
<p><img src="https://devopscube.com/content/images/2025/03/git-commit-ids-min-1.png" alt="How to Checkout/Clone From a Specific Git Commit Id (SHA)" class="image--center mx-auto" /></p>
<h2 id="heading-objects">objects</h2>
<p>If we move into the sub folder named as <em>objects</em> inside the .<em>git</em> folder, then we can see the first two characters of the hashes of all the commits we had done till now inside our main working folder.</p>
<p><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1769438712626/04b19593-60c1-415e-8e2f-6409be26bcb2.png" alt class="image--center mx-auto" /></p>
<p>Further if we move inside one of these two alphanumeric hashes, we will get all the hashes starting with the same two characters. Upon reading one of the hashes using the cat command, for example: <code>cat</code> <code>4a07d916c1802d606a41e00b52e2068f6510ded6</code> , it will give all the information and the changes we have made in that commit in an encrypted format.</p>
<p>If you want to read this encrypted information, then we have to move outside the <em>.git</em> folder and run the command as follows, for example: <code>git cat-file -p 4a07d916c1802d606a41e00b52e2068f6510ded6</code></p>
<p>Now it will provide all the information in a readable format. The information provides us data about the parent node of the commit, author, email of the author and the changes we had done in the corresponding commit.</p>
]]></content:encoded></item><item><title><![CDATA[Git for Beginners: Basic and Essential Commands]]></title><description><![CDATA[Git is a version control system developed by Linus Torvalds. It provides us a variety of features like keeping the track of a code base giving us…]]></description><link>https://chaiaurcode-assignments.hashnode.dev/git-for-beginners-basic-and-essential-commands</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/git-for-beginners-basic-and-essential-commands</guid><category><![CDATA[Git]]></category><category><![CDATA[GitHub]]></category><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sat, 17 Jan 2026 19:45:39 GMT</pubDate><content:encoded><![CDATA[<h2 id="heading-why-git-is-used-for">Why Git is used for?</h2>
<p>Git is a version control system developed by Linus Torvalds. It provides us a variety of features like keeping the track of a code base giving us traceability, switching to the previous or future versions of the codebase (if any), maintains a log file storing the data of the contributor, etc.</p>
<h2 id="heading-starting-with-git">Starting with Git</h2>
<p>To use git, just simply download it from the web by the help of a browser of your own choice.</p>
<p>Now open your terminal and navigate to the file or folder you want to track with the help of Git. After that and write the following command: <mark>git init</mark> <em>.</em> This command will initialize your corresponding file/folder with the git software and from onwards every change you make within the file, will be tracked by Git.</p>
<p>Generally, there are four main Git operations that everyone should know:</p>
<p><mark>git init</mark></p>
<p><mark>git add filename</mark></p>
<p><mark>git commit -m “message“</mark></p>
<p><mark>git push</mark></p>
<p>We have already discussed the init command, now let’s discuss the rest of them.</p>
<p>The <mark>git add</mark> command takes all your changes to an area called as staging area. The staging area is a phase in which you are telling the git software that, these things are ready to be committed.</p>
<p>And now, you will be questioning that what is the meaning of commit?? Commit is nothing but simply means tracking our code. In more simpler way, it is basically taking the snap shot of our current code and storing them with some data and a message attached to it.</p>
<p>Further you may ask, why are we doing it in a two step process, can’t we just omit the <mark>git add</mark> command and directly commit them. Well it is partially true, but when we are working with a large code base, or professional environment, we are required to do the work in phases, so that it will be easy for others to understand what we had changed and what is the purpose of it. It is also a safer option because if we want to change something, we can edit it at the moment before committing it.</p>
<p>(Note: If there are multiple files to add, instead of writing all the file names, simply write <mark>git add .</mark> to add all the files to the staging area)</p>
<p>Now the next step is to commit all the files waiting in the staging are as we discussed before. Here’s the command: <mark>git commit -m “message“</mark>. Remember that when we make a commit, we have to always add a message with it so that it will be easy for us and our fellow contributors to know what the commit was about.</p>
<p>(Note: Generally the message we write with the commit command should be in present tense. For ex: <mark>git commit -m “fix navigation tab“</mark>)</p>
<p>At last, we use the push command as <mark>git push</mark> to push all our changes to our web repository(fancy name for folder). These repositories and stored on web by popular sites like GitHub, GitLabs, Bitbucket, etc. These sites helps us to track our code and collaborate with our fellow contributors online.</p>
<p>Some of the other popular git commands are:</p>
<p><mark>git log</mark>, <mark>git status</mark>, <mark>git clone</mark>, <mark>git branch</mark>, etc.</p>
<p><img src="https://docs.ionos.space/git-workflow.jpeg" alt="An Introduction to Git: The Basics Every Beginning Developer Should Know |  Blog | IONOS Deploy Now" class="image--center mx-auto" /></p>
]]></content:encoded></item><item><title><![CDATA[Why Version Control Exists: The Pen-drive Problem]]></title><description><![CDATA[Let’s imagine we are building a app or website, so obviously the code base would be of a decent size. One day while working on it, we suddenly bumped into…]]></description><link>https://chaiaurcode-assignments.hashnode.dev/why-version-control-exists-the-pen-drive-problem</link><guid isPermaLink="true">https://chaiaurcode-assignments.hashnode.dev/why-version-control-exists-the-pen-drive-problem</guid><category><![CDATA[ChaiCode]]></category><category><![CDATA[Chaiaurcode]]></category><category><![CDATA[PendriveProblem]]></category><dc:creator><![CDATA[Rudra Prasad Hati]]></dc:creator><pubDate>Sat, 17 Jan 2026 18:41:25 GMT</pubDate><content:encoded><![CDATA[<p>Let’s imagine we are building a app or website, so obviously the code base would be of a decent size.</p>
<p>One day while working on it, we suddenly bumped into an error which we couldn’t solve. So to solve the error, we took help from a friend named as X. To provide the friend with the source code, what we did is: we stored the entire source code inside a pen-drive, and gave it to our friend. After some time, our friend solved the error, and stored the fresh new fixed code inside the same pen-drive and gave it back. But now when we opened the source code, there was a new problem. The problem was not about a bug, but of unfamiliarity. The new source code provided by our friend seems new to us, as we didn’t know in which places the code had been changed and for what purpose. Here arises the problem of traceability.</p>
<p>Further, in later discussions our friend X told us that he was interested in the software we were building, so he want to contribute in it. So what we did is, we again provided the entire code base to him through the help of the same pen-drive. Here comes the twist, after some days, when we had a conference together, we noticed that while developing some features we both have edited some of our pre-existed code on our own different local PCs. And now, there exists two different versions of the same software which is a big issue.</p>
<p>To solve all these issues, a version control system was strongly needed which would help us in traceability, and there would a single version of the source code of an software. And this is where Git was developed.</p>
<p>Git is a version control system developed by Linus Torvalds as a side project to keep and manage the code base of his main project i.e. Linux OS.</p>
<p><img src="https://media2.dev.to/dynamic/image/width=1600,height=900,fit=cover,gravity=auto,format=auto/https%3A%2F%2Fdev-to-uploads.s3.amazonaws.com%2Fuploads%2Farticles%2Fie23qui5v4j1efcq02he.png" alt="Why Version Control Exists: The Pen Drive Problem - DEV Community" class="image--center mx-auto" /></p>
]]></content:encoded></item></channel></rss>