<?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 orgen hoxia on Medium]]></title>
        <description><![CDATA[Stories by orgen hoxia on Medium]]></description>
        <link>https://medium.com/@orgen.hoxia?source=rss-f10d0502e90d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*dmbNkD5D-u45r44go_cf0g.png</url>
            <title>Stories by orgen hoxia on Medium</title>
            <link>https://medium.com/@orgen.hoxia?source=rss-f10d0502e90d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 09:41:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@orgen.hoxia/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[Working with Claude: How an AI Coding Agent Helped Me Build a Responsive Website]]></title>
            <link>https://medium.com/@orgen.hoxia/working-with-claude-how-an-ai-coding-agent-helped-me-build-a-responsive-website-daf42f143975?source=rss-f10d0502e90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/daf42f143975</guid>
            <dc:creator><![CDATA[orgen hoxia]]></dc:creator>
            <pubDate>Sat, 10 Oct 2026 00:44:37 GMT</pubDate>
            <atom:updated>2026-10-10T00:44:37.193Z</atom:updated>
            <content:encoded><![CDATA[<p>As a Level 3 Software Development student, I have been using Claude to help with my coding. This short article explains what a coding agent is, how Claude has helped me, and the exact kind of prompt I used to turn a desktop-only website into a responsive one.</p><h3>What is a coding agent?</h3><p>A chatbot answers questions in a conversation, and you copy the code it gives you into your project yourself. A coding agent goes a step further. It can read the files in a project, understand how they fit together, make changes across several files and run commands to check the result, while the developer stays in charge and reviews what it does.</p><p>Claude can be used in both ways. In a chat I can paste in code and ask questions, and with a coding agent such as Claude Code the same model works directly on a project. Either way, the quality of the result depends on how well I describe the job, which is why I have learnt to write my prompts carefully.</p><h3>How Claude has helped my coding</h3><p>Claude has become a useful study partner and assistant while I learn to code. It helps me in a few clear ways:</p><ul><li><strong>Explaining code.</strong> When I meet unfamiliar syntax or a confusing error message, it explains what is happening in plain language.</li><li><strong>Finding mistakes.</strong> It spots problems such as a mistyped class name or a missing closing tag that I could stare at for a long time.</li><li><strong>Suggesting improvements.</strong> It shows simpler or cleaner ways to write something, so I learn better habits.</li></ul><p>The biggest benefit came when I used it to make my website responsive.</p><h3>Making my website responsive</h3><p>My FoodSpot website looked right on a desktop screen but broke on mobile. Instead of asking something vague like “make this work on mobile”, I wrote a structured prompt:</p><blockquote><em>Act as an experienced front end developer. You will be given a complete HTML and CSS project that works well on desktop, however it is not responsive and breaks on mobile screens. Your task is to make the necessary changes to the code, without complicating it, to make it fully responsive and mobile friendly. Ensure you add comments to the code so a beginner front end developer is able to interpret the changes you made and take it from there.</em></blockquote><p>I then supplied my complete HTML and CSS files along with the prompt. Each sentence of it has a job, and together they follow the same parts of a good prompt: context, task, constraints and output format.</p><h3>Why the prompt worked</h3><p>The wording followed a clear order, and each step made the answer better:</p><ol><li><strong>It set a role.</strong> “Experienced front end developer” points the answer towards professional front-end practice.</li><li><strong>It described the starting point.</strong> Saying the project already works well on desktop told Claude what to keep and what to fix.</li><li><strong>It named the problem.</strong> “Breaks on mobile screens” gave a clear target instead of a vague request.</li><li><strong>It limited the scope.</strong> “Without complicating it” kept the solution simple, rather than a rewrite full of extra tools.</li><li><strong>It asked for beginner-friendly comments.</strong> Comments on every change meant I could learn from the code and “take it from there” myself.</li></ol><h3>The result on mobile</h3><p>I used the same approach on two of my projects, and both now fit a phone screen. On the left is my portfolio, with its links and content stacked in a single column. On the right is FoodSpot, where the navigation has collapsed into a menu icon and the banner text and button fit the width of the screen.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/494/1*wYiPqscpJ-SPJ8Y-EofrLg.png" /></figure><h3>Conclusion</h3><p>Claude and coding agents have made me a faster and more confident developer. The most important lesson is that the quality of the answer depends on the quality of the prompt: give a role, explain the situation, state the problem, set limits and say how you want the result delivered. With that structure, and with careful review, an AI coding agent is a powerful tool for learning as well as for getting work done.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=daf42f143975" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prompt Engineering: The Skill Every Software Developer Should Know]]></title>
            <link>https://medium.com/@orgen.hoxia/prompt-engineering-the-skill-every-software-developer-should-know-4315342fe485?source=rss-f10d0502e90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4315342fe485</guid>
            <dc:creator><![CDATA[orgen hoxia]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 11:01:49 GMT</pubDate>
            <atom:updated>2026-10-08T11:01:49.184Z</atom:updated>
            <content:encoded><![CDATA[<p>Prompt engineering is the skill of writing instructions that get reliable, useful results from an AI model, and it is quickly becoming as basic to a developer’s toolkit as using version control or reading documentation. This article explains what it is, how a good prompt is built, and how to use it to write, debug and ship better software.</p><h3>What prompt engineering is, and why developers need it</h3><p>A prompt engineering is the skill of writing instructions that get reliable, useful results from an AI model, and it is quickly becoming as basic to a developer’s toolkit as using version control or reading documentation. This article explains what it is, how a good prompt is built, and how to use it to write, debug and ship better software.</p><p>s the input you give to a large language model (LLM): a question, an instruction, some code, or all three. Prompt engineering is the practice of designing that input so the model returns what you actually need, and of testing and improving it until it does so consistently.</p><p>It matters for developers in two ways. First, AI assistants now sit inside editors, terminals and code review tools, and the quality of what they produce depends heavily on how clearly you ask. A vague request gets a generic answer, while a precise one gets code you can use. Second, many applications now call LLMs through an API, and in those products the prompt is part of the source code. It has to be written, versioned, tested and maintained like any other component.</p><p>Prompt engineering does not replace programming knowledge. A model can produce plausible but wrong code, and only a developer who understands the problem can judge whether the answer is correct. The skill is really a form of clear technical communication: stating requirements, constraints and expected output precisely, which is what good developers already do when they write tickets, specifications and tests.</p><h3>The anatomy of a good prompt</h3><p>A strong prompt is usually built from a handful of parts. Not every prompt needs all of them, but running down the list quickly shows what is missing when an answer disappoints.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*-dKGydg3QAea3n2qYH7jcA.png" /></figure><p>Each part answers one question the model would otherwise have to guess at.</p><ol><li><strong>Context:</strong> tell the model about the environment it is working in, such as the language, framework, version and any relevant project details. Without it the model has to guess and may write code for the wrong version or library. Example: “Node.js 20 project, plain JavaScript, no external libraries.”</li><li><strong>Task:</strong> the one thing you want done, written as a direct instruction that starts with a verb. A single clear task gives a better answer than several mixed together. Example: “Fix the bug in the function below so it returns the average of an array.”</li><li><strong>Input:</strong> the material the model should work on, such as the code, the full error message or the data. Keep it separate from your instructions and include only what is relevant. Example: the average function pasted between &lt;code&gt; tags.</li><li><strong>Constraints:</strong> the rules the answer must follow, including what must not change. They stop the model from being too helpful, for example by renaming functions or adding libraries you did not ask for. Example: “Return 0 for an empty array. Do not change the function name or its parameters.”</li><li><strong>Examples:</strong> one or more samples of an input and the output you want. Showing the pattern is often clearer than describing it, especially for formats and writing style. Example: a sample commit message, followed by a request for another one in the same style.</li><li><strong>Output format:</strong> the shape of the answer, which makes it easier to read, review or process. Example: “Show the corrected function, then explain the change in one sentence”, or “Reply only with JSON”.</li></ol><h3>Core techniques</h3><p>A small set of techniques covers most everyday needs. Each one fixes a specific kind of weak answer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/500/1*JTzxhGDBQP6W2Gf6XQ7d7Q.png" /></figure><p>Each card pairs a technique with the problem it solves and a short example.</p><ul><li><strong>Be specific.</strong> Say exactly what the code should do and what happens when the input is bad. “Parse ISO 8601 dates, raise ValueError if invalid” names the date format and the failure behaviour, so the model has nothing to guess.</li><li><strong>Give context.</strong> The model does not know your project. Naming the framework and the test tool, as in “Django 5 project that uses pytest”, makes it use the right APIs and write tests in the right style.</li><li><strong>Show examples.</strong> Two sample commit messages show the tone, length and format all at once, and the model copies that pattern for the third. This is easier than describing the style in words.</li><li><strong>Set a role.</strong> “Act as a senior reviewer focused on security” tells the model which problems to look for and how to phrase its feedback, so you get a security-minded review instead of general comments.</li><li><strong>Ask for reasoning.</strong> Asking it to explain what is going wrong before it gives the fix makes the model work through the problem step by step, and lets you check its logic as well as its code.</li><li><strong>Request structured output.</strong> Naming the exact fields, as in “JSON: file, line, issue”, gives a response that another program can read directly. Saying “reply only with JSON” stops the model adding extra chat around it.</li><li><strong>Break work into steps.</strong> Asking for a plan first lets you correct the approach before any code exists, and building one function at a time keeps each answer small enough to test.</li></ul><p>Giving examples, often called few-shot prompting, is one of the most powerful techniques. Showing the model two or three correct input and output pairs usually works better than describing the format in words. Asking for structured output matters most in applications, because a program can only use a response it can reliably parse.</p><h3>Prompting for code in practice</h3><p>The difference between a weak and a strong prompt is easiest to see on a real bug. Here is a typical first attempt:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/523/1*YSgoiwAD0oz6Qi7OX7VlXg.png" /></figure><p>The model has no function, no error and no idea what “work” means, so it can only guess. Compare it with this version, which uses the parts described earlier:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/506/1*b9--syTMMInFO0FgDu97aA.png" /></figure><p>This prompt states the environment, the symptom, the expected behaviour, the limits and the format of the answer, and it keeps the code separate from the instructions. A good answer is short and easy to verify:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/510/1*-tBFGnHX7gKrL3-vVTY5fw.png" /></figure><p>The same habits work for other coding tasks. Include the full error message or stack trace when debugging, say what you expected and what happened instead, and trim the code to the smallest example that shows the problem. When asking for new code, ask for tests alongside it, and ask the model to explain its choices so you can check its reasoning. Whatever the model returns, read it and run it before you trust it.</p><h3>Common mistakes and responsible use</h3><p>Most disappointing results come from a small number of habits:</p><ul><li><strong>Being vague.</strong> “Make it better” gives the model nothing to aim at. Say what better means: faster, shorter, easier to read or safer.</li><li><strong>Asking for too much at once.</strong> A request to build a whole application tends to produce shallow code. Split it into small tasks and check each one.</li><li><strong>Trusting the output without checking.</strong> Models can write code that looks right but contains bugs, uses outdated APIs or calls functions and packages that do not exist. Run the code, write tests and read the documentation.</li><li><strong>Sharing sensitive data.</strong> Never paste passwords, API keys, personal data or confidential company code into a tool you are not authorised to use, and follow your employer’s rules on AI tools.</li><li><strong>Ignoring prompt injection.</strong> If an application puts user text or web content into a prompt, that text can contain instructions that try to override yours. Keep untrusted content clearly separated from your instructions, give the model only the permissions it needs, and check its output before acting on it, for example before running a command or a database query.</li></ul><p>Generated code deserves the same scrutiny as code from any third party: review it for security problems and licensing concerns before it goes into a product.</p><h3>Conclusion</h3><p>Prompt engineering comes down to habits developers already have: being precise about requirements, giving context, showing examples, testing results and reviewing output critically. Learning to build prompts from clear parts, using a few core techniques and improving them through small, tested changes will make AI tools far more useful, and it is essential for anyone building products on top of them.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4315342fe485" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Building FoodSpot, a Responsive Restaurant Website]]></title>
            <link>https://medium.com/@orgen.hoxia/building-foodspot-a-responsive-restaurant-website-7f17bd224023?source=rss-f10d0502e90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f17bd224023</guid>
            <dc:creator><![CDATA[orgen hoxia]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 10:17:02 GMT</pubDate>
            <atom:updated>2026-10-08T10:17:02.619Z</atom:updated>
            <content:encoded><![CDATA[<p>As a Level 3 Software Development student, I built FoodSpot, a responsive one-page restaurant website, from an empty file using only HTML and CSS. This article walks through how I planned it, how I structured the code, and how I made it work.</p><h3>The finished site</h3><p>FoodSpot is a one-page website for a fictional restaurant. The home page opens with a full-width photo banner, the headline “Always Choose Good”, and a pink “Our Menu” button, with the logo and navigation links in a sticky header above it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XiLXDUihhfUvUEFr7Z8n3Q.png" /></figure><h3>The header and navigation</h3><p>I started at the top of the page with the header. It holds the logo and the navigation menu:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*ytbBnPFsWXLSW5i6LWl2pQ.png" /></figure><p>There are three ideas here. The logo is a link, and the span around &quot;Spot&quot; lets the CSS colour that half of the name red while &quot;Food&quot; stays dark. The navigation is an unordered list, because a menu is really a list of links, and CSS turns it into a horizontal row. The sticky class is the hook for keeping the header visible at the top as the visitor scrolls. For now the links use href=”#”as placeholders, and the next step is to point each one at the id of its section so the page scrolls to it.</p><h3>The banner</h3><p>The banner is the first thing a visitor sees, so it needed a clear message and one obvious action:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*jLdlQs98yrwRcUCmrqL8BQ.png" /></figure><p>The section is the full-width block, and the div with the class content groups the text so it can be centred on top of the background photo. The heading is an h2, the paragraph is placeholder text for now, and the call-to-action is a link styled as a button with the btn class. Using a link rather than a button element makes sense here because it takes the visitor to another part of the page.</p><h3>Reusable building blocks</h3><p>Once the header and banner were done, I noticed that many parts of the page share the same shape: a picture with some text. Instead of inventing new markup for every section, I reused a small set of class names.</p><p>The About section uses a two-column row. Each col50 takes half of the width, with the text on one side and the picture on the other:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*Bw1ovOGhJmdq84I19lAebw.png" /></figure><p>The section headings all use the same trick as the logo: a span with the class make-pinkish wraps the first letter, so &quot;About Us&quot;, &quot;Our Menu&quot; and &quot;Contact Us&quot; all get a pink capital from one shared CSS rule.</p><h3>The contact form</h3><p>The contact section is the first place where visitors give something back, so it uses a form with three fields and a send button:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/658/1*6A0rsHnwT57CMcEinEiSWg.png" /></figure><p>The type=”email” attribute makes the browser check that the address looks valid, and placeholder shows a hint inside each field. Wrapping every field in an inputbox div gives the CSS one class to control spacing and width, which is what lets the form stack neatly on a phone. The page ends with a footer containing a short line of text and a row of social icons.</p><h3>Lessons learnt and improvements</h3><p>Building the site from scratch taught me more than following a tutorial would have, and it also showed me what to improve next:</p><ul><li><strong>Class names must match exactly.</strong> A single mistyped class or attribute in the HTML silently stops a CSS rule from applying, with no error message. Checking names between index.html and style.css became a habit.</li><li><strong>Every image needs an alt attribute.</strong> My first version left them out. Alt text helps screen-reader users and shows something when an image fails to load.</li><li><strong>Placeholder text must be replaced.</strong> The Lorem ipsum paragraphs and the generic “Customer 1” and “Experts 1” labels need real content before the site is finished.</li><li><strong>Navigation links should point somewhere.</strong> Giving each section an id and linking to it from the header turns the # placeholders into working links.</li><li><strong>Images should live in the project.</strong> Photos loaded from an external image host can disappear, so storing them in an images folder is safer.</li><li><strong>Validating the HTML catches small mistakes.</strong> An online validator flags problems such as invalid attributes that the browser quietly ignores.</li></ul><h3>Conclusion</h3><p>FoodSpot started as an empty file and ended as a complete, responsive website. Planning the page into sections, writing clean semantic HTML, reusing a few consistent class names and adding media queries for smaller screens were the habits that made it manageable. The project pulled together everything from my Level 3 course on Software Development learning HTML, CSS, Flexbox and responsive design, and the improvements above are my next steps.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f17bd224023" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Flexbox Explained: Building Flexible, Responsive Layouts with CSS]]></title>
            <link>https://medium.com/@orgen.hoxia/flexbox-explained-building-flexible-responsive-layouts-with-css-ce4ea63a3c79?source=rss-f10d0502e90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/ce4ea63a3c79</guid>
            <dc:creator><![CDATA[orgen hoxia]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 09:56:27 GMT</pubDate>
            <atom:updated>2026-10-08T09:56:27.424Z</atom:updated>
            <content:encoded><![CDATA[<p>CSS Flexbox is a layout system that lets the items in a container grow, shrink, wrap and line up without fixed sizes or positioning tricks, which makes it one of the most useful tools for responsive design. This article explains how it works and how to use it to build layouts that adapt to any screen size.</p><h3>The layout problem</h3><p>Responsive design means a website adapts to the device it is viewed on, from a small phone to a wide desktop monitor. Before Flexbox, developers built layouts with floats, inline-block elements and fixed widths. These were never designed for page layout, so they needed workarounds such as clearing floats, and tasks like centring something vertically or making columns the same height were surprisingly hard.</p><p>Flexbox, short for the Flexible Box Layout Module, was created to solve exactly this. It gives a container control over how its children are sized, spaced, aligned and ordered, and it recalculates all of that automatically when the available space changes.</p><h3>Flex containers and flex items</h3><p>Flexbox works with two kinds of element. The <strong>flex container</strong> is the parent, and you create it by setting display:flex; on it. Its direct children automatically become <strong>flex items</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/666/1*SUsUV4bFUijTJNBwcLccag.png" /></figure><p>With just that one declaration, the three items line up side by side in a row instead of stacking, because the default direction is horizontal.</p><p>Everything in Flexbox is described along two axes. The <strong>main axis</strong> is the direction the items are laid out in, and the <strong>cross axis</strong> runs at right angles to it. In the default row layout the main axis runs left to right and the cross axis runs top to bottom. Changing flex-direction to column swaps them, so the main axis runs top to bottom. Knowing which axis is which is the key to using Flexbox, because justify-content always works along the main axis and align-items always works along the cross axis.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*FjrsTbef0zoknWC5lTLYEg.png" /></figure><p>Here the container uses align-items:center, so the items sit in the middle of the cross axis.</p><h3>Properties for the container</h3><p>These properties are set on the flex container and control how all of its items are arranged.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/790/1*oRXpl89vT6Q7gB52DyqDFg.png" /></figure><p>Centring an item both horizontally and vertically, once a famously difficult task, now takes only justify-content:center and align-items:center.</p><h3>Flexbox and responsive design</h3><p>A flex layout starts from the content and the space available rather than from fixed widths, so the same HTML can sit in a row on a wide screen and stack on a narrow one.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/641/1*M1DHiwoRfkIJyVrCviNe2A.png" /></figure><p>Flexbox does this by wrapping items onto new lines when they no longer fit in the row.</p><p>The simplest responsive pattern combines flex-wrap, gap and a flexible flex-basis:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/664/1*bqlXpgGgBFn7ZHxq13wuPQ.png" /></figure><p>Each card wants to be at least 250px wide and grows to share any spare space. When the row runs out of room the browser wraps the last card onto a new line, so the layout moves from three columns to two to one as the screen narrows, without a single media query.</p><p>When the layout needs to change more deliberately, Flexbox works well with media queries. A mobile-first approach stacks the items by default and switches to a row once the screen is wide enough:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/663/1*gxA5ywCt-WwCIdDXJTGcEw.png" /></figure><h3>Flexbox or Grid?</h3><p>CSS Grid is the other modern layout system, and the two are designed to work together rather than compete. Flexbox is one-dimensional: it lays items out along a single row or column. Grid is two-dimensional: it controls rows and columns at the same time.</p><p>As a rule of thumb, use Flexbox for components and for content-driven layouts, such as navigation bars, button groups, card rows and centring. Use Grid for the overall page layout, such as a header, sidebar, main area and footer. It is common to use Grid for the page structure and Flexbox inside each section.</p><h3>Conclusion</h3><p>Flexbox replaced a collection of hacks with a layout system that was built for the job. Once the two axes make sense, a handful of properties (display, flex-direction, justify-content, align-items, flex-wrap and flex) are enough to build most everyday layouts, and they keep working as the screen size changes. Combined with the viewport meta tag and a few media queries, Flexbox is one of the quickest ways to make a site responsive, and a good foundation before moving on to CSS Grid.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ce4ea63a3c79" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fundamentals of HTML, CSS and the CSS Box Model]]></title>
            <link>https://medium.com/@orgen.hoxia/fundamentals-of-html-css-and-the-css-box-model-d8dadca2b354?source=rss-f10d0502e90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8dadca2b354</guid>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[orgen hoxia]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 09:41:25 GMT</pubDate>
            <atom:updated>2026-10-08T09:41:25.794Z</atom:updated>
            <content:encoded><![CDATA[<p>Every web page is built from three layers: HTML gives it structure, CSS gives it presentation, and the CSS box model decides how much space each element takes up. On my Level 3 Software Development course I learnt how these fit together, and this article sets out the fundamentals.</p><h3>HTML: the structure of a page</h3><p>HTML is the standard language for describing the structure and content of a web page. It is not a programming language: it uses elements, written as tags, to tell the browser what each piece of content is, such as a heading, a paragraph, a link or an image.</p><p>Most elements have an opening tag, some content and a closing tag. Attributes in the opening tag give extra information, for example the href attribute on a link says where it points. Some elements, such as img and br, are &quot;void&quot; elements with no content and no closing tag.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/639/1*4NBM-2gJ_sqhzynjv4RTow.png" /></figure><p>The tag name p means paragraph, and the class attribute is a hook that CSS can use to select this element.</p><p>Every HTML page follows the same basic skeleton:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/667/1*wIkspXTkkTgDteQEkbvcIw.png" /><figcaption>CODE</figcaption></figure><p>The head holds information about the page, such as its title and links to stylesheets. The body holds everything the visitor sees.</p><p>The elements I used most often were:</p><ul><li><strong>Headings</strong> h1 to h6, with h1 as the main title.</li><li><strong>Paragraphs</strong> p and <strong>lists</strong> ul , ol and li.</li><li><strong>Links</strong> &lt;a&gt; and <strong>images</strong> img, which needs src and alt attributes.</li><li><strong>Containers</strong> div and span, which group content so it can be styled.</li><li><strong>Semantic elements</strong> such as header, nav, main, section,article and footer, which describe the purpose of each part of the page.</li></ul><p>Semantic elements matter because they make a page easier to maintain and more accessible: screen readers and search engines use them to understand the layout.</p><h3>CSS: the presentation of a page</h3><p>CSS (Cascading Style Sheets) controls how HTML elements look: their colours, fonts, spacing, size and layout. Keeping CSS separate from HTML means the structure and the styling can be changed independently, and one stylesheet can style a whole website.</p><p>A CSS rule has a selector, which says which elements to style, and a block of declarations in curly braces. Each declaration is a property and a value:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/661/1*udjg3I0wruFeubbi57Xp3g.png" /><figcaption>code</figcaption></figure><p>The three most common selectors are:</p><ul><li><strong>Element selectors</strong> such as h1, which match every element of that type.</li><li><strong>Class selectors</strong> such as .highlight, which match any element with class=highlight and can be reused.</li><li><strong>ID selectors</strong> such as main-title, which match the one element with that id.</li></ul><h3>The CSS box model</h3><p>In CSS, every element on a page is treated as a rectangular box. The box model describes the layers that make up that box, and it explains how the size of an element and the space around it are calculated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/572/1*WPFB2tjRssbMC0y_OJVvNg.png" /></figure><p>Read the box from the centre outwards: content, then padding, then border, then margin.</p><p>From the inside out, the four layers are:</p><ol><li><strong>Content:</strong> the text, image or other material itself. Its size is set with width and height.</li><li><strong>Padding:</strong> clear space between the content and the border. It takes on the element’s background colour.</li><li><strong>Border:</strong> a line around the padding and content, set with border-width, border-style and border-color, or the border shorthand.</li><li><strong>Margin:</strong> transparent space outside the border that pushes other elements away. It never has a background colour.</li></ol><p>Padding, border and margin can each be set for all four sides at once, or for one side at a time, such as margin-top or padding-left. A shorthand with several values runs clockwise from the top: margin:10px 20px 30px 40x means top, right, bottom, left.</p><h3>Conclusion</h3><p>HTML, CSS and the box model each answer a different question: what is on the page, how does it look, and how much room does it take up. Writing clean semantic HTML first, then styling it with a shared stylesheet, makes sites easier to build and maintain. Understanding the box model, and setting box-sizing:border-box, removes most of the confusion about sizes and spacing that I met when starting out. The next step is to build on these basics with layout tools such as Flexbox and Grid.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8dadca2b354" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Software Development Methodologies: SDLC, Waterfall, Agile and Kanban]]></title>
            <link>https://medium.com/@orgen.hoxia/software-development-methodologies-sdlc-waterfall-agile-and-kanban-a23adab63c2a?source=rss-f10d0502e90d------2</link>
            <guid isPermaLink="false">https://medium.com/p/a23adab63c2a</guid>
            <category><![CDATA[softare-development]]></category>
            <dc:creator><![CDATA[orgen hoxia]]></dc:creator>
            <pubDate>Thu, 08 Oct 2026 09:26:49 GMT</pubDate>
            <atom:updated>2026-10-08T09:26:49.458Z</atom:updated>
            <content:encoded><![CDATA[<p>The method a team uses to turn an idea into working software shapes how it plans, builds, tests and delivers. On my Level 3 Software Development course I learnt about the software development life cycle (SDLC) and three ways of running it: Waterfall, Agile and Kanban.</p><h3>The software development life cycle (SDLC)</h3><p>The SDLC is a structured process that takes software from an initial idea to a working product that is maintained over time. Its purpose is to produce good-quality software on time and within budget, and to give everyone on the team a shared picture of what happens next.</p><p>Most versions of the SDLC include the same core stages:</p><ol><li><strong>Planning:</strong> decide the goals, scope, budget, timescale and risks of the project.</li><li><strong>Requirements analysis:</strong> gather and document what users and stakeholders need the software to do.</li><li><strong>Design:</strong> plan the architecture, database, user interface and how components will fit together.</li><li><strong>Implementation:</strong> write the code, usually in small pieces that are reviewed by other developers.</li><li><strong>Testing:</strong> check that the software works, meets the requirements and is free of serious bugs.</li><li><strong>Deployment:</strong> release the software so that real users can use it.</li><li><strong>Maintenance:</strong> fix bugs, apply updates and add improvements after release.</li></ol><p>The SDLC itself is not a single method. Waterfall, Agile and Kanban are different ways of organising these same stages, and the main difference is how and when each stage happens.</p><h3>Waterfall</h3><p>Waterfall is the traditional, linear approach. Each SDLC stage is completed in full before the next one starts, and work flows downwards like water over a series of steps. Requirements are agreed and signed off at the start, then the project moves through design, implementation, testing and deployment in order, with maintenance after release.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/621/1*yuFF2GxjoSfKgxxqlll8Fg.png" /></figure><p>Work moves down one step at a time, and there is no planned route back to an earlier phase.</p><p>Waterfall works well when requirements are clear and unlikely to change, such as in construction-style projects, safety-critical systems or work with strict regulation and documentation rules.</p><p><strong>Strengths</strong></p><ul><li>Simple to understand and manage, because every phase has clear start and end points.</li><li>Detailed documentation is produced at each stage, which helps with handover and audits.</li><li>Cost and timescale are easier to estimate early on.</li></ul><p><strong>Weaknesses</strong></p><ul><li>Changes are difficult and expensive once a phase is finished.</li><li>Testing happens late, so serious problems may only be found near the end of the project.</li><li>The customer does not see working software until late, so misunderstandings can go unnoticed for months.</li></ul><h3>Agile</h3><p>Agile is an iterative approach that delivers software in small, working increments instead of one big release. It grew out of the 2001 Agile Manifesto, which values individuals and interactions, working software, customer collaboration and responding to change. Those four values are ranked above processes and tools, documentation, contract negotiation and following a fixed plan.</p><p>The most common Agile framework is Scrum. Work is split into short time-boxed iterations called sprints, usually one to four weeks long. Each sprint starts with planning, where the team picks items from the product backlog. The team meets briefly each day for a stand-up, then finishes with a sprint review to show the work and a retrospective to talk about how to improve. Scrum roles include the product owner, who sets priorities, the Scrum master, who helps the team follow the process, and the developers who build the product.</p><p><strong>Strengths</strong></p><ul><li>Changing requirements are welcomed, even late in development.</li><li>Customers see working software early and often, so feedback arrives sooner.</li><li>Frequent testing and review catch problems while they are still cheap to fix.</li><li>Close teamwork and regular retrospectives improve the team over time.</li></ul><p><strong>Weaknesses</strong></p><ul><li>Costs and end dates are harder to predict at the start.</li><li>It relies on constant communication and an engaged customer or product owner.</li><li>Less documentation can make it harder for new people to join the project.</li><li>Scope can creep if priorities are not managed carefully.</li></ul><h3>Kanban</h3><p>Kanban is a visual method for managing work as it flows through a process. The word is Japanese for “visual signal”, and the method began in Toyota’s car factories before being adapted for software. Work items are shown as cards on a board, and the board is split into columns that match the stages of the team’s workflow, such as To Do, In Progress, Testing and Done.</p><p>Kanban has no fixed sprints and no required roles. Instead it relies on a few simple practices: make the workflow visible, limit the amount of work in progress (WIP) in each column, manage the flow of work and keep improving the process. A WIP limit stops a team from starting too many things at once, so bottlenecks show up quickly and work is finished rather than left half-done.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/641/1*0OkhmjGNfmvpLG4YPM7TaQ.png" /><figcaption>progress</figcaption></figure><p>Each card is one task, and it moves to the right as it progresses.</p><p><strong>Strengths</strong></p><ul><li>Very flexible, because new work can be added at any time and priorities can change.</li><li>The board makes progress and bottlenecks easy for everyone to see.</li><li>WIP limits reduce multitasking and help work to be completed faster.</li><li>Easy to adopt without changing roles or team structure.</li></ul><p><strong>Weaknesses</strong></p><ul><li>With no time-boxes, deadlines and long-term plans can be harder to track.</li><li>A board that is not kept up to date quickly becomes misleading.</li><li>It gives less structure than Scrum, so new teams may need more discipline.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z_UaG97wRpCJIiiNfB94PQ.png" /><figcaption>comparison</figcaption></figure><h3>Comparing the three approaches</h3><p>Waterfall plans everything up front, Agile plans a little at a time, and Kanban plans continuously around the flow of work.</p><p>Waterfall</p><p>Agile (Scrum)</p><p>Kanban</p><p>Structure</p><p>Linear phases, one after another</p><p>Short sprints (1 to 4 weeks)</p><p>Continuous flow on a board</p><p>Handling change</p><p>Difficult and costly</p><p>Welcomed at each sprint</p><p>Possible at any time</p><p>Delivery</p><p>One release at the end</p><p>Working increment every sprint</p><p>Items released as they are finished</p><p>Customer involvement</p><p>Mostly at the start and end</p><p>Regular, throughout</p><p>As needed</p><p>Documentation</p><p>Heavy</p><p>Light, as needed</p><p>Light</p><p>Roles</p><p>Defined project roles</p><p>Product owner, Scrum master, developers</p><p>No required roles</p><p>Best suited to</p><p>Fixed, well-understood requirements</p><p>Evolving requirements</p><p>Ongoing work, support and maintenance</p><h3>Conclusion</h3><p>The main thing I learnt is that no single approach is best for every project. Waterfall suits projects with fixed requirements and strict documentation needs, Agile suits projects where requirements will change and feedback matters, and Kanban suits teams with a steady stream of work such as support or maintenance. In practice many teams mix ideas, for example using Scrum sprints with a Kanban board to track tasks (often called Scrumban).</p><p>When choosing an approach, I would ask three questions: how stable are the requirements, how often does the customer need to see progress, and how much does the team need to adapt along the way? Understanding the SDLC stages first makes it much easier to see what each method changes and why.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a23adab63c2a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>