<?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 Bill Nduka on Medium]]></title>
        <description><![CDATA[Stories by Bill Nduka on Medium]]></description>
        <link>https://medium.com/@billnduka01?source=rss-7f5a32080e0d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*omwtfhSq8SVZFZ0d</url>
            <title>Stories by Bill Nduka on Medium</title>
            <link>https://medium.com/@billnduka01?source=rss-7f5a32080e0d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:43:27 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@billnduka01/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[The Unspoken Rules of Git: Writing Commits Like a Senior Engineer]]></title>
            <link>https://medium.com/@billnduka01/the-unspoken-rules-of-git-writing-commits-like-a-senior-engineer-0cfcb4476231?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/0cfcb4476231</guid>
            <category><![CDATA[github]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[devcareerxcoursera]]></category>
            <category><![CDATA[git]]></category>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 13:23:18 GMT</pubDate>
            <atom:updated>2026-11-11T13:23:18.147Z</atom:updated>
            <content:encoded><![CDATA[<p>As I progress through the IBM Full-Stack JavaScript Developer track, the complexity of my projects is ramping up. Early on, version control was just a way to save my work. I would type git commit -m &quot;fixed stuff&quot; and move on. But as I prepare for real-world engineering roles, I am learning that a professional GitHub presence requires more than just making your repositories public. It requires writing commits that other humans can actually read.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/691/0*5G9d_0cBVgWtwZIp" /></figure><p>There is a whole layer of Git conventions that tutorials rarely teach, but enterprise engineering teams enforce religiously. Here are the unspoken rules of version control that instantly separate junior codebases from senior ones:</p><ul><li><strong>The Imperative Mood (Active Voice):</strong> Have you ever wondered why standard Git messages are written as “Fix bug” instead of “Fixed bug” or “Fixing bug”? It is because Git commit messages are designed to complete a specific sentence: <em>“If applied, this commit will [your message here].”</em> Writing “If applied, this commit will fixed bug” makes no sense. The imperative mood treats commits as instructions for what the code <em>will do</em>, rather than a diary entry of what you <em>did</em>.</li><li><strong>The 50/72 Rule:</strong> A professional commit message has a strict formatting limit. The subject line should be 50 characters or less, forcing you to be concise. If you need to explain <em>why</em> the change was made, you leave a blank line and write a body paragraph wrapped at 72 characters. This ensures the logs remain highly readable in terminal windows.</li><li><strong>Conventional Commits:</strong> Enterprise teams use strict prefixes to categorize their work. A commit should never just say “Updated header.” It should say feat: add user profile dropdown or fix: resolve mobile overflow issue. Using prefixes like feat: (new feature), fix: (bug fix), chore: (maintenance), and refactor: (code restructuring) allows teams to automatically generate changelogs and trace system regressions instantly.</li><li><strong>Atomic Commits:</strong> A commit should only do one thing. If you fix a database schema and update a CSS button in the same commit, rolling back the broken database will also delete the button fix. Commits must be logical, isolated units of work.</li></ul><p>During a recent DevCareer session, we discussed the importance of building a highly professional GitHub footprint, right down to generating well-structured README files for every project. Clean commit history is the next step in that professional visibility.</p><p>What is the worst Git commit message you have ever written or encountered in a shared codebase?</p><p><strong>#SoftwareEngineering #Git #GitHub #JavaScript #IBMFullStack #DevCareerXCoursera #BuildInPublic</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0cfcb4476231" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Git Clone vs Fork: Stop Mixing Them Up]]></title>
            <link>https://medium.com/@billnduka01/git-clone-vs-fork-stop-mixing-them-up-d85bf8c5e9e2?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/d85bf8c5e9e2</guid>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 18:00:48 GMT</pubDate>
            <atom:updated>2026-11-09T18:00:48.383Z</atom:updated>
            <content:encoded><![CDATA[<p>Your first open source contribution starts with a question: do I clone this repo or fork it?</p><p>Usually both. They do different jobs, and mixing them up is how people end up with broken remotes and pull requests that go nowhere.</p><h4>The one-sentence difference</h4><ul><li><strong>Clone</strong> is a <strong>Git</strong> command. git clone &lt;url&gt; copies a repository, with its full history, onto your machine.</li><li><strong>Fork</strong> is <strong>not</strong> a Git command. It’s a <strong>GitHub (or GitLab) feature</strong> that copies a repository into your own account on the server.</li></ul><h4>Why fork at all?</h4><p>You can’t push to a repo you don’t have write access to. Cloning someone else’s project gets the code onto your laptop, but your push will be rejected. A fork gives you a copy you <em>can</em> push to. A <strong>pull request</strong> is how you ask the original maintainers to pull your changes in.</p><h4>Three places, three names</h4><pre>original repo  (&quot;upstream&quot;)<br>        │  click Fork on GitHub<br>        ▼<br> your fork      (&quot;origin&quot;)   ◀──── git push ────┐<br>        │  git clone                            │<br>        ▼                                       │<br> your computer  (local)  ── commit on a branch ─┘</pre><pre> your fork ── Pull Request ──▶ original repo</pre><h4>The full workflow</h4><p>bash</p><pre># 1. Fork on GitHub, then clone YOUR fork (check your username is in the URL)<br>git clone https://github.com/YOUR-USERNAME/project.git<br>cd project<br># 2. Point a second remote at the original<br>git remote add upstream https://github.com/original-owner/project.git<br>git remote -v   # origin = your fork, upstream = the original<br># 3. Work on a branch, never directly on main<br>git checkout -b fix-typo-in-readme<br>git add .<br>git commit -m &quot;Fix typo in README&quot;<br># 4. Push to YOUR fork, then open a pull request on GitHub<br>git push origin fix-typo-in-readme</pre><p><strong>Shortcut:</strong> with the GitHub CLI, gh repo fork owner/project --clone does the fork, the clone, and sets origin and upstream for you.</p><h4>Forks don’t update themselves</h4><p>Once you fork, your copy is frozen at that moment. If the original moves on, you have to sync it, and there are three ways:</p><ol><li>Click <strong>Sync fork</strong> on your fork’s page on GitHub.</li><li>Run gh repo sync YOUR-USERNAME/project -b main.</li><li>Use plain Git:</li></ol><p>bash</p><pre>git fetch upstream<br>git checkout main<br>git merge upstream/main<br>git push origin main</pre><p>Sync <em>before</em> you start new work so your pull request doesn’t conflict with changes you didn’t know about.</p><h4>Which one do you need?</h4><p>SituationUseYour own repo, or a team repo where you have write access<strong>Clone</strong>Contributing to a project you can’t push to<strong>Fork, then clone your fork</strong>Just reading or running someone’s code locally<strong>Clone</strong>Taking a project in your own direction<strong>Fork</strong></p><h4>Forks are bigger than pull requests</h4><p>Forking is also how communities protect themselves. When Terraform’s license changed in 2023, the community forked its last open version into OpenTofu. When Redis changed licenses in 2024, the Linux Foundation backed Valkey. Both forks now have their own governance and keep their open licenses.</p><p>That connects to last week. A fork carries the original’s license with it. Your fork of an MIT project is still bound by the MIT notice, and a fork of a GPL project must stay GPL if you distribute it.</p><h4>Common mistakes</h4><ul><li><strong>Cloning the original instead of your fork.</strong> Check the username in the URL.</li><li><strong>Committing straight to </strong><strong>main on your fork.</strong> Branch for every change.</li><li><strong>Forgetting </strong><strong>upstream.</strong> Without it you can’t sync.</li><li><strong>Assuming the fork updates automatically.</strong> It doesn’t.</li></ul><p><strong>Further reading:</strong> GitHub Docs: “Fork a repo” and “Syncing a fork.”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d85bf8c5e9e2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Public ≠ Open Source: A Developer’s Guide to Software Licenses]]></title>
            <link>https://medium.com/@billnduka01/public-open-source-a-developers-guide-to-software-licenses-43899d107f78?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/43899d107f78</guid>
            <category><![CDATA[licensing]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 05:30:08 GMT</pubDate>
            <atom:updated>2026-11-03T05:30:08.092Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*l9KyNkxSqp3OM9XQ.jpg" /></figure><p>You find the perfect library on GitHub. It solves your exact problem, it has thousands of stars, and the code is right there. One thing is missing: a LICENSE file.</p><p>Can you use it?</p><p>Legally, no. Software is under exclusive copyright by default, and making a repo public doesn’t change that. GitHub’s terms let people view and fork public repos on the platform, but that isn’t permission to use, modify, or ship the code in your own product. Only a license grants that.</p><p>So a license is the set of permissions an author chooses to hand out while keeping the copyright.</p><h4>The spectrum: permissive to copyleft</h4><p>Picture a dial. At one end, almost anything goes. At the other, whatever you build must stay open too.</p><p>LicenseCommercial useMust you share your changes?Patent grantThe catch<strong>MIT</strong>YesNoNo express grantKeep the copyright and license notice<strong>Apache 2.0</strong>YesNoYesState your changes; no trademark use<strong>MPL 2.0</strong>YesOnly modified MPL filesYesCopyleft applies file by file<strong>GPL 3.0</strong>YesYes, when you distributeYesThe derivative work must also be GPL<strong>AGPL 3.0</strong>YesYes, even over a networkYesHosting a modified version triggers it</p><ul><li><strong>MIT</strong> is the shortest and most popular. Do almost anything, keep the notice.</li><li><strong>Apache 2.0</strong> gives the same freedom plus an explicit patent grant from contributors.</li><li><strong>MPL 2.0</strong> is the middle ground. Modify an MPL file and you share that file, but your new files can stay proprietary.</li><li><strong>GPL 3.0</strong> is strong copyleft. Distribute software built on GPL code and the whole thing must go out under the GPL, with source.</li><li><strong>AGPL 3.0</strong> adds the network clause, which matters for web apps. Letting users interact with your modified version over a network triggers the source-sharing duty.</li><li><strong>LGPL</strong> sits between GPL and permissive, so non-GPL software can link to the library.</li></ul><p>One more trap: <strong>Creative Commons</strong> licenses are for writing, images and docs, not code.</p><h4>Licenses decide who controls a project</h4><p>Two recent stories show this.</p><p><strong>Terraform → OpenTofu.</strong> In August 2023, HashiCorp moved Terraform from MPL 2.0 to the Business Source License. The BSL restricts use in competing products, so Terraform was no longer open source by the OSI definition. The community forked the last MPL-licensed version as OpenTofu, which joined the Linux Foundation in September 2023 and stays under MPL 2.0.</p><p><strong>Redis → Valkey.</strong> In March 2024, Redis moved from BSD to RSALv2/SSPLv1. The Linux Foundation, AWS, Google, Oracle and others backed Valkey, a BSD fork of Redis 7.2.4. In 2025, Redis 8 added AGPLv3 as another option.</p><p>The lesson is that a license is a promise about a specific version of the code. Releases already published under an open license stay open, which is why the community could fork from the last open version. That is next week’s topic.</p><h4>Your dependencies’ licenses become your problem</h4><p>Every package you install brings its own license. GPL code generally can’t be folded into proprietary software you distribute. MIT, BSD and Apache code is easy to include almost anywhere, with one wrinkle: Apache 2.0 is compatible with GPL-3.0 but not GPL-2.0-only.</p><p>In a Node project you can audit everything in one command:</p><p>bash</p><pre>npx license-checker --summary</pre><p>Declare your own license in package.json with an SPDX identifier:</p><p>json</p><pre>{ &quot;license&quot;: &quot;MIT&quot; }</pre><h4>How to choose</h4><ol><li><strong>Want maximum adoption?</strong> MIT.</li><li><strong>Want adoption plus patent protection?</strong> Apache 2.0.</li><li><strong>Want improvements to stay open?</strong> GPL-3.0.</li><li><strong>Want hosted versions to stay open too?</strong> AGPL-3.0.</li></ol><p>Not sure? <a href="https://choosealicense.com/">choosealicense.com</a> walks you through it. On GitHub, create a file named LICENSE and the editor offers a license template picker.</p><h4>The mistakes to avoid</h4><ul><li>Publishing with no license at all</li><li>Copying MIT code but dropping the notice</li><li>Using Creative Commons for software</li><li>Ignoring your dependencies’ licenses</li></ul><p><em>I’m a student, not a lawyer. This is a learning summary, not legal advice.</em></p><p><strong>Further reading:</strong> choosealicense.com, the OpenTofu announcement at opentofu.org, GitHub Docs: “Licensing a repository.”</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43899d107f78" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Zombies of Tech: What Actually Powers the World]]></title>
            <link>https://medium.com/@billnduka01/the-zombies-of-tech-what-actually-powers-the-world-0ad4a7a1c5c8?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/0ad4a7a1c5c8</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cobol]]></category>
            <category><![CDATA[jquery]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Fri, 23 Oct 2026 11:52:23 GMT</pubDate>
            <atom:updated>2026-10-23T11:52:23.448Z</atom:updated>
            <content:encoded><![CDATA[<p>In Week 9 of the IBM Full-Stack JavaScript Developer track, I stepped back from tutorials and asked a different question: what is the internet actually running on?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Lv_qO1Bg97lXU9MBSZMcgw.png" /></figure><p>The answer isn’t the framework that trended on X this morning. It’s older, quieter, and far more stubborn.</p><p><strong>COBOL: the 67-year-old that moves your money.</strong> Created in 1959, COBOL is still widely estimated to sit behind about 95% of ATM transactions and 80% of in-person banking transactions, with some 220 billion lines in production and around $3 trillion in commerce a day. One example: back in 2012, Bank of New York Mellon reported maintaining 112,500 COBOL programs, about 343 million lines of code. The catch is a talent gap. Universities largely stopped teaching it decades ago, and banks are now experimenting with AI tools to help maintain and modernize it.</p><p><strong>PHP and WordPress: the web’s workhorse.</strong> PHP is used by about 70% of websites whose server-side language is known. WordPress, built on it, runs roughly 42% of all websites.</p><p><strong>jQuery: declared dead, still everywhere.</strong> It’s on about 67% of all websites. Even jQuery 1.x, a version from the 2000s, is still found on around 13%.</p><p><strong>Linux: the invisible foundation.</strong> About 62% of websites with an identifiable OS run Linux, and the broader Unix family covers around 92%. Every system on the TOP500 supercomputer list runs Linux too.</p><p><strong>And the new stuff earns its place.</strong> React Native isn’t legacy, but it shows why tools survive: Shopify moved its flagship app to it and now shares about 86% of its code across iOS and Android, up from roughly 5%. Efficiency like that is why a tool lasts.</p><p><strong>My takeaway:</strong> the technologies that last aren’t the newest, they’re the ones that are reliable, and rewriting something that works is expensive and risky. As a developer, learning the new tools matters, but so does respecting the old systems that keep running.</p><p>What’s the oldest piece of tech you’ve seen still running in production?</p><p><em>Sources: W3Techs (2026), Reuters (2017), Computerworld (2012), Shopify’s React Native migration. Usage figures cover only sites where the technology is detectable.</em></p><p><strong>#SoftwareEngineering #COBOL #jQuery #WordPress #Linux #IBMFullStack #DevCareer #Coursera</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0ad4a7a1c5c8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Blueprinting the Web: 5 Architectural Patterns and Where to Find Them]]></title>
            <link>https://medium.com/@billnduka01/blueprinting-the-web-5-architectural-patterns-and-where-to-find-them-c0b12ddc6d27?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c0b12ddc6d27</guid>
            <category><![CDATA[devcareerxcoursera]]></category>
            <category><![CDATA[full-stack-developer]]></category>
            <category><![CDATA[coursera]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 23:51:01 GMT</pubDate>
            <atom:updated>2026-10-12T23:51:01.348Z</atom:updated>
            <content:encoded><![CDATA[<p>As I move into Week 8 of the IBM Full-Stack JavaScript Developer track, I’m expanding on my previous deep-dive into monoliths versus microservices. Architecture isn’t just about making code work; it’s about making it fit the specific shape of the problem you are trying to solve.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0mVXmjsSGsqle0ry" /><figcaption>Photo by <a href="https://unsplash.com/@joakimnadell?utm_source=medium&amp;utm_medium=referral">Joakim Nådell</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Not every application needs a sprawling, complex infrastructure, and not every simple app can survive being bundled into a single tier. Here are five core architectural patterns I’ve been exploring, mapped directly to the real-world applications that rely on them:</p><ul><li><strong>2-Tier Architecture (The Direct Line):</strong> In a 2-tier system, the client interface communicates directly with the database. It is fast and straightforward but harder to scale securely.</li><li><em>Real-World Example:</em> <strong>Messaging Apps.</strong> Basic internal messaging tools often use this to push and pull data directly from the server to the client with minimal friction.</li><li><strong>3-Tier Architecture (The Standard Bearer):</strong> This introduces a “middleman.” You have the Presentation tier (UI), the Application tier (Business Logic), and the Data tier (Database).</li><li><em>Real-World Example:</em> <strong>Standard Web Apps.</strong> Most traditional e-commerce sites or corporate web applications use this to keep their interface code entirely separate from their database operations.</li><li><strong>Peer-to-Peer (The Decentralized Network):</strong> There is no central server. Every node (user) acts as both a client and a server, sharing resources directly with others.</li><li><em>Real-World Example:</em> <strong>Cryptocurrency.</strong> Bitcoin and other blockchain networks rely entirely on P2P architecture to distribute ledgers and verify transactions without a central bank.</li><li><strong>Event-Driven (The Reactive System):</strong> Instead of following a strict sequence of commands, the system sits and waits for “events” (like a user clicking a button or a sensor triggering) and reacts accordingly in real-time.</li><li><em>Real-World Example:</em> <strong>Ride-Sharing.</strong> When an Uber or Bolt driver updates their location, that “event” is instantly broadcasted to the rider’s app to update the map live.</li><li><strong>Microservices (The Specialized Fleet):</strong> The application is split into dozens (or hundreds) of tiny, independent services that talk to each other via APIs.</li><li><em>Real-World Example:</em> <strong>Social Media.</strong> Platforms like Instagram or X handle messaging, feed ranking, video processing, and authentication as completely separate services. If the direct messaging service crashes, your feed still loads perfectly.</li></ul><p>Understanding these patterns is proving that software engineering is heavily reliant on choosing the right blueprint before laying the first brick. Which of these patterns do you work with the most on a daily basis?</p><p><strong>#SoftwareArchitecture #WebDevelopment #IBMFullStack #JavaScript #DevCareer #Coursera</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c0b12ddc6d27" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Code We Write Writes the Future: Why Software Engineering Needs an Ethics Check]]></title>
            <link>https://medium.com/@billnduka01/the-code-we-write-writes-the-future-why-software-engineering-needs-an-ethics-check-4a547ca687bd?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a547ca687bd</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[devcareerxcoursera]]></category>
            <category><![CDATA[learning-in-public]]></category>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Mon, 05 Oct 2026 10:18:23 GMT</pubDate>
            <atom:updated>2026-10-05T10:18:23.269Z</atom:updated>
            <content:encoded><![CDATA[<p>As I cross into Week 7 of my IBM Full-Stack JavaScript Developer track via the Coursera X Devcareer scholarship, my focus has shifted from the mechanics of coding to the philosophy of engineering. We spend so much time obsessing over how to build things — React hooks, Express middleware, Docker containers — that we often forget to ask ourselves a much more important question: <em>should</em> we build this, and <em>how</em> are we building it?</p><p>This is where the Code of Ethics in software engineering comes in.</p><p>The transition from a “developer” to an “engineer” isn’t just about scaling applications to handle millions of users. It is about understanding the massive responsibility that comes with writing instructions that dictate how the modern world functions.</p><p>To understand what happens when software engineers ignore this responsibility, we don’t have to look far. Consider one of the most infamous corporate scandals of the 21st century: <strong>The Volkswagen “Dieselgate” Emissions Scandal.</strong></p><p>In 2015, the EPA discovered that VW had been installing “defeat devices” in their diesel cars. But this wasn’t a mechanical device — it was software. Software engineers actively wrote code that detected when the car was undergoing an official emissions test (by monitoring steering wheel movement, engine speed, and barometric pressure).</p><p>When the software detected a test, it ran the engine in a low-emissions mode. When the car was back on the open road, the software switched off the controls, allowing the cars to emit up to 40 times the legal limit of nitrogen oxide.</p><p>Someone had to sit at a keyboard, write the if/else statements for that logic, test it, commit it to a repository, and deploy it. That wasn&#39;t a bug. It was a catastrophic ethical failure by a team of engineers who chose blind compliance over professional responsibility.</p><p>As I learn to build full-stack applications, handling backend databases and user authentication, the VW scandal serves as a stark reminder. Code is not neutral. Whether we are deciding how to encrypt user passwords, how transparent we are about data collection, or whether we push a heavily bugged feature to meet a deadline, we are making ethical choices.</p><p>The ACM/IEEE Software Engineering Code of Ethics dictates that we must act consistently with the public interest. Our primary obligation is to the safety, health, and welfare of the end-user.</p><p>Writing code that “survives contact with reality” means ensuring that the reality we are shaping is safe, honest, and secure.</p><p><strong>#SoftwareEngineering #CodeOfEthics #JavaScript #LearningInPublic #TechEthics #Coursera #DevCareer</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a547ca687bd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Iceberg Beneath the UI: The Hidden Depth of Frontend Development]]></title>
            <link>https://medium.com/@billnduka01/the-iceberg-beneath-the-ui-the-hidden-depth-of-frontend-development-48f8ba74a109?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/48f8ba74a109</guid>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 17:44:52 GMT</pubDate>
            <atom:updated>2026-09-30T17:44:52.962Z</atom:updated>
            <content:encoded><![CDATA[<h3>What I’ve learned about why frontend is far more than “making things pretty”</h3><p>The surface</p><p>People see the visible layer: layouts, colours, animations. That layer matters, but it’s only the part above the waterline.</p><p>What lives below</p><p><strong>Rendering.</strong> Browsers turn HTML and CSS into pixels through a process of parsing, layout, and painting. Understanding it explains why some changes are cheap and others make a page feel sluggish.</p><p><strong>Performance.</strong> Users leave slow pages. Image sizes, bundle sizes, and layout shifts all affect how a site feels. Google’s Core Web Vitals exist to measure this.</p><p><strong>Accessibility.</strong> Your interface must work with a keyboard and a screen reader. Semantic HTML, focus management, and sensible labels are part of the job.</p><p><strong>State and data.</strong> Modern interfaces constantly juggle data from APIs, user input, and local state. Keeping all of that predictable is a craft.</p><p><strong>Security.</strong> Frontend code handles user input, and cross-site scripting (XSS) is a real risk if you render it carelessly.</p><p><strong>Compatibility.</strong> Users have different browsers, devices, screen sizes, and network speeds. “It works on my machine” isn’t enough.</p><p><strong>Tooling and testing.</strong> Package managers, bundlers, linters, and automated tests are part of daily work.</p><p>Why this matters for learners</p><p>Seeing the full picture early helps you plan your learning. You don’t need to master everything at once. Start with HTML, CSS, and JavaScript fundamentals, then add depth one layer at a time.</p><p>Conclusion</p><p>Frontend development sits where engineering, design, and human behaviour meet. That’s a large part of what makes it a rewarding field.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=48f8ba74a109" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Sass vs Less: What CSS Preprocessors Are and Why They Still Matter]]></title>
            <link>https://medium.com/@billnduka01/sass-vs-less-what-css-preprocessors-are-and-why-they-still-matter-71ef95ffde0d?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/71ef95ffde0d</guid>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 17:38:50 GMT</pubDate>
            <atom:updated>2026-09-30T17:38:50.870Z</atom:updated>
            <content:encoded><![CDATA[<h3>A beginner’s guide to writing CSS with superpowers</h3><p>The problem with plain CSS (historically)</p><p>Plain CSS used to have no variables, no nesting, and no way to reuse blocks of styles. Large stylesheets became repetitive and hard to maintain. Preprocessors were created to fix this. You write in a richer syntax, and a compiler turns it into standard CSS.</p><p>Sass</p><p>Sass is the most popular preprocessor. It has two syntaxes, and SCSS (which looks like CSS with extra features) is the one most people use.</p><p>scss</p><pre>$brand: #4f46e5;</pre><pre>@mixin card {<br>  padding: 1rem;<br>  border-radius: 8px;<br>}</pre><pre>.button {<br>  background: $brand;<br>  @include card;</pre><pre>  &amp;:hover {<br>    opacity: 0.9;<br>  }<br>}</pre><p>Less</p><p>Less works in much the same way, with @ for variables and a slightly different mixin syntax.</p><p>less</p><pre>@brand: #4f46e5;</pre><pre>.card() {<br>  padding: 1rem;<br>  border-radius: 8px;<br>}</pre><pre>.button {<br>  background: @brand;<br>  .card();</pre><pre>  &amp;:hover {<br>    opacity: 0.9;<br>  }<br>}</pre><p>Key features they share</p><ul><li><strong>Variables:</strong> change a brand colour in one place.</li><li><strong>Nesting:</strong> group related rules together.</li><li><strong>Mixins:</strong> reuse style blocks, often with parameters.</li><li><strong>Partials and imports:</strong> split styles into organised files.</li></ul><p>Sass vs Less at a glance</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/887/1*F9lBSbIq7B_WK71D2CM7tA.png" /></figure><p>Do we still need them?</p><p>Native CSS has caught up on two big fronts: custom properties (variables) and nesting. For small projects you may not need a preprocessor at all. For larger codebases, mixins, functions, loops, and modular file structure are still strong reasons to use Sass in particular.</p><p>Conclusion</p><p>Learning a preprocessor teaches you how stylesheets scale. Even if you end up using native CSS, understanding these tools will make you better at organising styles.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71ef95ffde0d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Styling Is the Most Underestimated Skill in Frontend Development]]></title>
            <link>https://medium.com/@billnduka01/why-styling-is-the-most-underestimated-skill-in-frontend-development-be679b911ec5?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/be679b911ec5</guid>
            <category><![CDATA[dev-careers]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[css]]></category>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 17:25:09 GMT</pubDate>
            <atom:updated>2026-09-30T17:25:09.193Z</atom:updated>
            <content:encoded><![CDATA[<h3>I used to think CSS was the easy part. Here’s what changed my mind.</h3><p>The myth</p><p>There’s a quiet assumption among beginners that JavaScript is the “real” work and CSS is decoration. As I’ve worked through my frontend course, I’ve seen how wrong that is. Styling is where your code becomes an experience.</p><p>What styling actually involves</p><ul><li><strong>Layout:</strong> Flexbox and Grid are layout systems, and choosing between them takes real judgment.</li><li><strong>Responsiveness:</strong> Your interface has to work on screens from 320px phones to ultrawide monitors, and everything in between.</li><li><strong>Visual hierarchy:</strong> Size, weight, colour, and spacing tell users what matters on the page without a single word of instruction.</li><li><strong>Accessibility:</strong> WCAG recommends a minimum contrast ratio of 4.5:1 for normal text. Styling decisions determine whether people with low vision can read your page.</li><li><strong>The cascade and specificity:</strong> Understanding why a rule wins over another is a skill, and it’s the source of many “why won’t this work?” moments.</li><li><strong>Consistency:</strong> As projects grow, ad hoc styles turn into chaos unless you use tokens, naming conventions, or a design system.</li></ul><p>The cost of ignoring it</p><p>Users judge quickly, and they judge visually. A working feature that looks confusing will be perceived as a broken feature. Teams also pay later: messy CSS makes every future change slower and riskier.</p><p>How to level up</p><ol><li>Learn the box model, the cascade, and specificity properly before reaching for a framework.</li><li>Rebuild real interfaces you admire, pixel by pixel.</li><li>Test on real devices and with browser dev tools, not just your main monitor.</li><li>Run an accessibility check (Lighthouse is a good start) on everything you build.</li></ol><p>Conclusion</p><p>Logic makes software work, and styling makes it usable. Both deserve your respect, and learning CSS seriously will make you a better engineer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be679b911ec5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Monolith vs. Microservices: The Simplest Explanation I’ve Found]]></title>
            <link>https://medium.com/@billnduka01/monolith-vs-microservices-the-simplest-explanation-ive-found-551b8dd5a4e8?source=rss-7f5a32080e0d------2</link>
            <guid isPermaLink="false">https://medium.com/p/551b8dd5a4e8</guid>
            <dc:creator><![CDATA[Bill Nduka]]></dc:creator>
            <pubDate>Wed, 30 Sep 2026 16:58:11 GMT</pubDate>
            <atom:updated>2026-09-30T16:58:11.544Z</atom:updated>
            <content:encoded><![CDATA[<p>Last week, I wrote about the shift from a “developer” mindset to an “engineering” mindset. A huge part of that transition is understanding how applications are actually structured to handle scale.</p><p>As I get deeper into the IBM Full-Stack JavaScript Developer track, I’ve been exploring two fundamentally different ways to build software: Monolithic Architecture vs. Microservices.</p><p>Here is the simplest way I’ve come to understand the difference.</p><h3>🧱 The Monolith (The All-in-One)</h3><p>Think of a monolith like a massive, multi-tool pocket knife. The user interface, business logic, and database access are all woven into one giant codebase.</p><ul><li>The Upside: It is simple to develop, test, and deploy when you are just starting out.</li><li>The Downside: If one small feature breaks, the whole app can crash. Scaling requires duplicating the entire massive application.</li></ul><h3>🧩 Microservices (The Specialized Fleet)</h3><p>Instead of one massive application, microservices break the app down into smaller, independent services that communicate with each other (often via APIs).</p><ul><li>The Upside: You can update, deploy, or scale just one specific piece of the app without touching the rest.</li><li>The Downside: It introduces a lot of complexity. You now have to manage networks, data consistency, and deployments across multiple smaller apps using tools like Docker and Kubernetes.</li></ul><h3>Choosing the Right Tool</h3><p>As I build full-stack applications with React and Node.js, I’m realizing that choosing between the two isn’t about which is “better” — it’s about choosing the right tool for the scale of the problem.</p><blockquote><em>You don’t build a microservice architecture for a simple to-do app, and you don’t build a monolith for a global streaming platform.</em></blockquote><p>What is your preferred architecture when starting a brand new project, and at what point do you usually decide to break a monolith apart?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=551b8dd5a4e8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>