<?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 SudoLife🪒 on Medium]]></title>
        <description><![CDATA[Stories by SudoLife🪒 on Medium]]></description>
        <link>https://medium.com/@tcloudadewale?source=rss-d2f790969a2d------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*UV-RMqViVxFDOvvGGGaAkg.png</url>
            <title>Stories by SudoLife🪒 on Medium</title>
            <link>https://medium.com/@tcloudadewale?source=rss-d2f790969a2d------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 14:43:31 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@tcloudadewale/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[How I Installed Parrot OS Alongside Omarchy Without Wiping My Encrypted Linux Setup]]></title>
            <link>https://medium.com/@tcloudadewale/how-i-installed-parrot-os-alongside-omarchy-without-wiping-my-encrypted-linux-setup-71dd98be4175?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/71dd98be4175</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[open-source]]></category>
            <category><![CDATA[learning]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Tue, 03 Nov 2026 03:56:27 GMT</pubDate>
            <atom:updated>2026-11-03T03:56:27.647Z</atom:updated>
            <content:encoded><![CDATA[<p><em>A freezing live USB sent me down a rabbit hole of Ventoy, Btrfs, LUKS2, and dual booting on a 128 GB laptop.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NcCURLIfkjpUUyIThAEmRg.png" /></figure><p><strong>sudoLife 🪒 | Part 01 — Abidemi Adewale</strong></p><p><em>Cover illustration for the sudoLife series. The photographs below document my actual troubleshooting session.</em></p><p>I just wanted to try Parrot OS.</p><p>My plan was simple: put the ISO on my Ventoy USB, boot it, and explore some security tools. Omarchy was already working fine on my laptop. I wasn’t looking for another project.</p><p>Then Parrot started freezing.</p><p>The desktop would load, things would look promising, and just when I thought I could get on with it, the system would become painfully unresponsive. I wanted to learn cybersecurity. Instead, I was investigating why my laptop was struggling to run a live session.</p><p>That little USB experiment eventually led me to something I hadn’t planned: shrinking the Btrfs filesystem inside my encrypted Omarchy installation to make room for Parrot.</p><p>On a 128 GB SSD.</p><p>Here’s how that happened.</p><h3>Why I wanted Parrot in the first place</h3><p>I had already spent years using Ubuntu, and I was running Omarchy as my everyday system. But I wanted to spend more time learning cybersecurity and practising in environments I owned or had permission to test.</p><p>Parrot Security seemed like a useful place to start.</p><p>My laptop was a Dell Latitude 3120 with an Intel Pentium Silver N6000, roughly 8 GB of RAM, and a 128 GB NVMe SSD. Nothing extravagant, but it was what I had.</p><p>I also had a 16 GB USB drive running Ventoy.</p><p>Before touching the internal disk, I wanted to see how Parrot behaved from USB. That seemed reasonable enough.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RHddC9qiSBAcAZqccA2L4g.jpeg" /></figure><p><em>The original layout: a 2 GiB EFI partition and an approximately 117 GiB partition holding encrypted Omarchy. The USB drive appears separately.</em></p><h3>It booted. That wasn’t the whole victory.</h3><p>I copied the Parrot Security ISO onto the Ventoy drive and booted it.</p><p>Getting to the desktop was encouraging. But I wanted changes to survive a reboot — files, settings, and whatever I installed while learning.</p><p>So I moved on to persistence.</p><p>A live environment with persistence sounded like a convenient arrangement: carry my security environment around on a USB drive and keep my main installation separate.</p><p>I created a persistence image and checked the mounts. I also used a simple test file:</p><pre>echo &quot;parrot persistence is working&quot; &gt; ~/persistence-test.txt<br>cat ~/persistence-test.txt</pre><p>Reading it in that session confirmed that the file existed. To establish persistence across sessions, the important test was whether it remained after a reboot. The mount output also showed the overlay and persistent storage in use.</p><p>But saving a file and having a usable desktop turned out to be two different things.</p><p>The freezes kept coming.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xlKuUbp-1dkMUA6p1V9vkA.jpeg" /></figure><p><em>The test file and mount output from the persistence experiment. This photograph alone does not establish that the file survived a reboot.</em></p><h3>My first mistake would have been blaming the RAM</h3><p>A slow computer makes it tempting to jump straight to one explanation.</p><p>“Maybe this laptop needs more RAM.”</p><p>But before deciding that, I checked what the system was actually doing:</p><pre>free -h<br>uptime<br>df -h<br>vmstat 1 5</pre><p>One snapshot showed load averages of:</p><pre>15.39, 17.32, 16.14</pre><p>On a four-core laptop, those numbers caught my attention.</p><p>The memory output also showed several gigabytes available. That didn’t settle every question about memory pressure, but it wasn’t the straightforward “all the RAM is gone” situation I might have assumed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JS0pAB7tITsK8dO4WOVmtg.jpeg" /></figure><p><em>This snapshot showed about 5.4 GiB available memory alongside high load averages. Load average includes certain waiting tasks; it is not CPU utilisation expressed as a percentage.</em></p><p>I looked more closely at process states:</p><pre>ps -eo state,pid,comm,wchan:24 --sort=state | head -20</pre><p>Several tasks were in the D state, including storage-related processes.</p><p>Taken together with the I/O-wait observations, that pointed toward storage activity as an important part of the slowdown. It didn’t prove the USB drive was the sole cause.</p><p>That distinction mattered. I had evidence of a problem, not a complete explanation of every freeze.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4bqtjSDWbtqaJCFh_I6sFA.jpeg" /></figure><p><em>Storage-related tasks appeared in uninterruptible sleep. That supported further I/O investigation, rather than a definite diagnosis of a failed USB drive.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zbM9kla0ZPRGb39TWK3E9g.jpeg" /></figure><p><em>A further sample of process and vmstat output. Repeated observations helped me look beyond a single busy moment.</em></p><h3>Eventually, I changed the plan</h3><p>I could keep repairing and retesting the persistence setup. Or I could ask whether this was how I wanted to run my security environment regularly.</p><p>The USB experiment had been useful. Depending on it every time I wanted to practise was becoming frustrating.</p><p>So I decided to install Parrot on the internal SSD alongside Omarchy.</p><p>Then I checked the disk layout properly.</p><p>Omarchy occupied almost the entire drive.</p><p>And it was encrypted.</p><p>Of course it was 😂</p><h3>This was more than shrinking a partition</h3><p>Until then, “resize the Linux partition” sounded like one operation.</p><p>The actual layout had several layers. The GPT partition table defined the disk regions. One partition contained LUKS2 encrypted storage. Opening that container exposed the device holding Btrfs, and Btrfs held Omarchy’s subvolumes. The separate EFI System Partition held the boot files.</p><p>Changing the outer partition boundary without first making sure the filesystem fitted inside it could cut off data.</p><p>The order mattered.</p><p>For this setup, the work proceeded from the filesystem outward: reduce Btrfs, account for the encrypted mapping and its boundaries, then adjust the partition.</p><p><strong>This is a record of my particular installation, not a universal resizing guide. A verified backup is essential before attempting something similar.</strong></p><h3>Measure first. Touch the boundaries later.</h3><p>From the live environment, I inspected the disk and opened the encrypted Omarchy partition.</p><p>I mounted the Btrfs top-level subvolume read-only first so I could inspect its usage. These commands describe my existing device and mount point; they are not a complete procedure to follow on another computer:</p><pre>sudo cryptsetup open /dev/nvme0n1p2 omarchy_crypt<br>sudo mount -o ro,subvolid=5 /dev/mapper/omarchy_crypt /mnt/omarchy-check<br>sudo btrfs filesystem usage /mnt/omarchy-check</pre><p>The filesystem was roughly 117 GiB, with around 43 GiB used at that stage.</p><p>There was room to work with. But free space inside a filesystem isn’t automatically unallocated space another operating system can use.</p><p>I still had to make that space available outside Omarchy’s partition.</p><h3>Making room for the second system</h3><p>The target was a 72 GiB Btrfs filesystem inside a slightly larger encrypted partition.</p><p>After mounting the filesystem read-write at the appropriate stage, I reduced its size. I then unmounted it, adjusted the active encrypted mapping, closed that mapping, and changed the partition boundary using the disk’s actual sector layout.</p><p>I’m deliberately leaving the exact partition-changing commands out here. Their values depended on my disk, and copying those numbers onto a different installation would be dangerous.</p><p>The resulting arrangement was approximately 2 GiB for the EFI System Partition, 74 GiB for encrypted Omarchy, and 43 GiB available for Parrot. The Btrfs filesystem inside Omarchy’s partition was 72 GiB.</p><p>Before installing anything, I reopened the encrypted partition and checked that the Btrfs filesystem was still accessible.</p><p>That was reassuring.</p><p>But I still wanted to see Omarchy boot.</p><h3>Installing Parrot into the space I had created</h3><p>In the Parrot installer, I chose manual partitioning.</p><p>I created an ext4 root partition in the newly available space and mounted it at /.</p><p>I reused the existing EFI System Partition at /boot/efi without formatting it. Omarchy’s encrypted partition was left alone during the installation.</p><p>Parrot finished installing and booted successfully.</p><p>Half the job was done.</p><h3>The F12 moment</h3><p>I restarted the Dell and pressed F12.</p><p>The firmware menu showed several entries, including Parrot, Omarchy, Limine, Fedora, and Windows Boot Manager.</p><p>That list wasn’t proof that five operating systems were installed. Firmware can retain entries from earlier installations.</p><p>The entry I cared about was Omarchy.</p><p>I selected it.</p><p>It booted.</p><p>After all the freezing, checking, resizing, and double-checking, that was the result I had been working toward:</p><p><strong>Parrot booted. Omarchy booted.</strong></p><p>One laptop, two Linux environments.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3p9qaOKhiw5DJeJngrpcOA.jpeg" /></figure><p><em>The Dell’s F12 boot menu, photographed later while the dual-boot setup was still in place. Boot entries identify available firmware paths; they are not, by themselves, proof of successful boots.</em></p><h3>What made this worth writing about</h3><p>The useful part wasn’t simply getting another operating system installed.</p><p>It was learning to slow down when the system behaved differently from what I expected.</p><p>A frozen desktop pushed me to inspect memory and I/O. A nearly full disk layout pushed me to understand the difference between partitions, encryption mappings, and filesystems.</p><p>Changing direction also helped. The persistent USB never became the setup I wanted, but investigating it taught me things I needed for the next approach.</p><p>If you’re planning a similar project, start by understanding your own storage layout. Know which partition contains your system, where the boot files live, and what you can restore before changing anything.</p><p>My modest laptop was enough to make this an interesting project.</p><p>Apparently, all I needed to do was say, “Let me just try this.”</p><p><strong>Have you ever started a small Linux experiment and ended up learning something completely different? Tell me what happened in the comments.</strong></p><p><em>sudoLife 🪒 — Rooted in curiosity. Driven by the terminal.</em></p><h3>Technical references</h3><p><a href="https://www.ventoy.net/en/plugin_persistence.html">Ventoy persistence documentation</a> · <a href="https://btrfs.readthedocs.io/en/latest/btrfs-filesystem.html">Btrfs filesystem commands</a> · <a href="https://man7.org/linux/man-pages/man8/cryptsetup-resize.8.html">cryptsetup resize manual</a> · <a href="https://man7.org/linux/man-pages/man5/proc_pid_stat.5.html">Linux process states</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=71dd98be4175" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Laptop That Refused to Die: A 12-Hour Repair Saga]]></title>
            <link>https://medium.com/@tcloudadewale/the-laptop-that-refused-to-die-a-12-hour-repair-saga-c8aebc736c02?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8aebc736c02</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[computer-repair]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[tech-support]]></category>
            <category><![CDATA[windows]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Sun, 27 Sep 2026 14:07:41 GMT</pubDate>
            <atom:updated>2026-09-27T14:07:41.174Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/512/0*YSdfZbGj8xtF2r0-.jpg" /></figure><p>Someone handed me their HP laptop with a simple complaint: “It gets stuck after the welcome screen.”</p><p>I’ve heard this a hundred times. Usually it’s a five-minute fix. I said “no wahala, give me small time” and sat down expecting to hand it back within the hour.</p><p>Twelve hours, four repair tools, and one genuinely dramatic countdown timer later, I finally understood what “small time” actually meant that day.</p><p>Here’s the whole story told in a way I hope makes sense even if you’ve never opened a command prompt in your life.</p><h3>The Mystery of the Moving Cursor</h3><p>The laptop would boot, show the Windows logo, and then… nothing. Just a blank blue screen with a tiny arrow cursor you could move around with the mouse. No icons. No taskbar. No way in.</p><p>Here’s the thing that most people don’t realize: a moving cursor on a blank screen is actually good news. It means the computer itself is alive and well the brain (the operating system) loaded up fine. What’s missing is just the “front desk” the part of Windows called the <em>shell</em> that’s responsible for showing you your desktop, your icons, your start menu. Technically, it’s a program called explorer.exe, and for some reason, it wasn&#39;t showing up for work.</p><p>Think of it like walking into an office building. The lights are on, the elevators work, the building is clearly “on” but the receptionist never showed up, so you’re just standing in an empty lobby with no idea where to go.</p><p>The fix: force open Task Manager (a hidden control panel most people never touch) and manually tell the receptionist to come to work literally typing explorer.exe and hitting enter. And just like that, the desktop popped up like nothing happened.</p><p>Except it kept happening. Every single time we restarted the laptop, the receptionist would disappear again. Someone had to manually “call them back to work” on every single boot. That’s not a fix that’s a Band-Aid on a bullet wound.</p><h3>Digging for the Real Problem</h3><p>Time to find out <em>why</em> the receptionist kept vanishing.</p><p>Opening up the computer’s internal diagnostics showed something telling: the hard drive was working at 100% capacity, constantly, even when nothing much should have been happening. For context — this laptop had an old-school spinning hard drive, not the newer solid-state kind. Imagine a librarian trying to run back and forth to grab books for you as fast as physically possible, except the library is enormous and she’s exhausted. That’s basically what an old hard drive under heavy strain looks like.</p><p>There was also a background Windows feature running that tries to “predict” what you’ll open next and pre-load it into memory great idea on fast, modern computers, absolutely brutal on a tired old hard drive. I switched that off. Helped a little. The freeze still came back.</p><p>Which meant the hard drive itself needed a proper checkup.</p><h3>The Scan That Made Me Genuinely Worried</h3><p>Windows has a built-in tool that checks your hard drive for damage kind of like an MRI for your storage. I ran it, and it said: “Estimated time to finish: 21 hours.”</p><p>I laughed. Surely not.</p><p>A few minutes later, it updated itself: “Estimated time to finish: 240 hours.” That’s ten days.</p><p>Here’s the thing that actually matters, and it’s true of way more than just computers: when an estimate keeps getting worse instead of better as time goes on, that’s the real warning sign not the size of the number itself. A drive with minor issues gets fixed and the estimate drops. A drive that’s genuinely deteriorating keeps hitting new problems the deeper the scan goes, and the countdown balloons.</p><p>I let it run anyway. All night, through five separate stages. And against my low expectations, it actually finished patching up what it could. The drive wasn’t dead. It was bruised, but still standing.</p><h3>Round Two: The System Itself Was Wounded</h3><p>Rebooted the laptop, hoping for the best.</p><p>Same blank screen. Same missing receptionist.</p><p>Turns out, the earlier hard drive damage had already corrupted some of Windows’ own internal files before the drive got patched up like a building where some of the load-bearing walls got quietly damaged before anyone noticed. Windows has a tool that checks for this kind of internal file damage too. It found the damage, but told me flatly: it couldn’t fix all of it on its own.</p><p>There’s a deeper repair tool for exactly this situation one that reaches out to Microsoft’s servers to download fresh copies of whatever’s broken. I tried it. It refused to run, spitting out an error that made no logical sense given what I typed. After some digging, it became clear: even the <em>repair tool itself</em> was relying on files that were now damaged. The tool meant to fix things was, itself, part of the wreckage.</p><p>At that point, chasing individual broken files one by one stopped being worth it. Time for something bigger.</p><h3>The Big Move: Rebuilding Windows Without Losing Anything</h3><p>There’s a way to essentially give Windows a full transplant replace every single system file with a clean copy while keeping every document, photo, and installed program completely untouched. It’s not a factory reset. Nothing gets deleted. It’s more like renovating a house down to the studs while all your furniture and belongings just… float safely in place and get put right back when it’s done.</p><p>One important lesson I picked up here: if you try to start this process directly from a USB installer, Windows assumes you want to wipe everything and start fresh it won’t offer you the “keep my stuff” option. The trick is to boot into the <em>existing</em>, currently-limping Windows first, and launch the repair from inside it. Only then does it recognize there’s something worth preserving, and offers the safer path.</p><p>So that’s what we did. Installation crawled along remember, this hard drive was already tired taking roughly two hours, restarting the laptop multiple times along the way. At one point it sat at “Working on updates” and reset its percentage counter back to zero, which nearly gave me a mild heart attack before I realized that was just a new stage starting, not a failure.</p><p>And then, finally: the desktop loaded. On its own. No manual tricks. No missing receptionist. Every file, every folder, every program right where it should be.</p><h3>What This Whole Ordeal Actually Taught Me</h3><p>You don’t need to know anything about computers to get something out of this:</p><p>1. The scariest-looking symptom isn’t always the actual problem. A blank screen looks like total failure. It was actually just one small piece not showing up everything underneath was fine.</p><p>2. Watch the trend, not the number. An estimate of “21 hours” sounds bad. An estimate that jumps to “240 hours” the more it works is what should actually worry you because it means things are getting worse as it digs deeper, not better.</p><p>3. Sometimes small fixes aren’t the answer, and that’s okay. We tried the quick patches first reasonable and correct. But when they stopped working, the right move wasn’t to keep poking at symptoms; it was to zoom out and do the bigger repair properly.</p><p>4. Things that “still work” aren’t always healthy. The laptop technically ran the whole time we were diagnosing it. It just quietly struggled under the hood the entire time until it couldn’t anymore. Worth remembering for machines, and honestly, for a lot of other things too.</p><p>5. Fixed isn’t the same as fully recovered. The laptop works beautifully now. But given everything that drive went through, I’d still treat it gently back up what matters, and don’t be shocked if it eventually needs replacing rather than repairing again.</p><p>Twelve-plus hours. Four different repair attempts. One genuinely alarming countdown clock. But in the end, the old ProBook made it back receptionist and all.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8aebc736c02" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Console Warned Me. I Almost Ignored It Anyway.]]></title>
            <link>https://medium.com/@tcloudadewale/the-console-warned-me-i-almost-ignored-it-anyway-3779129b06ef?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/3779129b06ef</guid>
            <category><![CDATA[technology-programmin]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[devops]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Tue, 01 Sep 2026 08:35:46 GMT</pubDate>
            <atom:updated>2026-09-01T08:35:46.235Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UwrHa9MauWF1w-KeKmChZA.png" /></figure><p>“After a database is created, you can’t change its VPC.”</p><p>I read that line, nodded, and almost clicked past it without checking what VPC I’d actually selected. Ten seconds from now, that mistake would’ve cost me a full database rebuild. I didn’t know that yet. I was moving too fast to notice.</p><p>This is the story of how I built a full production style AWS architecture from a blank console no instructions, no hand-holding, just a business problem and six tasks that each depended entirely on the one before it. And how I almost broke it. Twice.</p><h3>The Setup</h3><p>The brief: a fictional company wants off their on-premises servers and onto AWS. Two weeks to a working prototype. My job design and deploy the whole thing from scratch. A VPC spanning two Availability Zones. A Multi-AZ Aurora database. Shared EFS storage. An Application Load Balancer. An Auto Scaling Group running real EC2 instances. All of it wired together to serve one actual WordPress site.</p><p>Six tasks. No safety net if I got one wrong because each task fed directly into the next. A mistake in task two doesn’t just break task two. It sits there quietly, waiting to break task five as well.</p><h3>The First Almost-Disaster</h3><p>Task two: build the database. Aurora MySQL, Multi-AZ for high availability, tucked into private subnets where nothing from the public internet could touch it.</p><p>I moved through the form quickly — I’d done Aurora setups before, this felt familiar. Instance type, credentials, subnet group. Then I hit the VPC dropdown, and it was already pre-filled.</p><p>I almost didn’t check it.</p><p>The console had defaulted to my account’s <strong>Default VPC -</strong> not the lab’s actual, carefully networked <strong>LabVPC</strong>. Same warning, sitting right there: <em>once this database is created, you can’t change its VPC.</em> Not “click here to fix it later.” Not “we’ll remind you.” Just this decision is permanent, made in about two seconds of not paying attention.<br>I caught it. Switched to LabVPC. The subnet group refreshed itself to the correct private database subnets, and I moved on with my pulse slightly elevated.</p><p>I told myself I’d be more careful going forward.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AnHFBWikAsjGinZW-KuY2w.png" /></figure><h3>The Second Almost-Disaster</h3><p>Task three: shared file storage with Amazon EFS, spread across both Availability Zones so either one going down wouldn’t take the storage layer with it.</p><p>Same VPC dropdown. Same default-VPC trap. Twice in two tasks.</p><p>This time it landed differently not “how did I miss this,” but “how did I <em>almost</em> miss this again, right after telling myself I’d be careful.” That’s the real lesson buried in this whole capstone: knowing a mistake is possible doesn’t automatically stop you from making it. Vigilance isn’t a switch you flip once. It’s something you have to actively hold onto, task after task, especially right when you start feeling comfortable.</p><p>Fixed it. Selected LabVPC. Mount targets landed in the correct app subnets, security groups locked to the EFS-specific group instead of the default. Moved forward, this time actually more careful.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pDigl-ACaPBx5BRaouqotg.png" /></figure><h3>When the Instructions Stopped Matching Reality</h3><p>Somewhere in the middle of the Aurora setup, I hit something the lab guide hadn’t accounted for: newer AWS console versions have quietly removed the simple “enable encryption” toggle for Aurora clusters. Encryption is just on. Tied to a KMS key. No checkbox to turn it off anymore.</p><p>The instructions assumed a console that didn’t exist anymore.</p><p>That’s its own kind of lesson, separate from the VPC mistakes: documentation ages, but the actual infrastructure keeps evolving underneath it. When a documented step stops existing, the answer isn’t to panic or assume you did something wrong it’s to ask whether the underlying goal is still achievable, and move forward with what the current console actually allows.</p><h3>Stitching It All Together</h3><p>By task five, I had a pile of values collected from every previous task a database endpoint, a file system ID, a load balancer’s DNS name, admin credentials all of which had to be fed correctly into one CloudFormation template to generate the launch configuration for the app servers.</p><p>This is the task that quietly tests whether you were paying attention three tasks ago. Copy one value wrong, and nothing fails loudly it just deploys something broken, and you won’t know until later, further downstream, when something that should work simply doesn’t.</p><p>Every value slotted in clean. Because I’d started writing them down the moment I created them, instead of trying to hunt them back down from memory under pressure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_SRhUbzCbZrTLvKPS-RePA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sNKkWxyFavEa5Yxlz3Q1SA.png" /></figure><h3>The Moment It Actually Worked</h3><p>Final task: Auto Scaling Group, two EC2 instances, attached to the load balancer, target tracking scaling enabled. I watched the console cycle through “Creating” for both instances, waiting for the health checks to catch up.</p><p>Then: <strong>2/2 Healthy.</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZpTH0SFEKCgb3ktuEPNQ3g.png" /></figure><p>I took the load balancer’s DNS name, added /wp-login.php to the end, and pasted it into a fresh browser tab the same move that, in an earlier lab, had failed on me for nearly forty minutes over a stale browser cache. This time, I half-expected another fight.</p><p>The WordPress login page loaded instantly.</p><p>I typed in the admin credentials. The dashboard loaded. “Howdy, wpadmin.” A live, functioning WordPress site database, storage, load balancing, and compute all correctly talking to each other running on infrastructure that, three hours earlier, had been an empty console and a page full of requirements.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2sl5b0-HlUawJQTdNk19Kw.png" /></figure><h3>What This Capstone Actually Tested</h3><p>I already knew what RDS does. I already knew what EFS does, what an ALB does, what an Auto Scaling Group does. That’s not what this lab was actually testing.</p><p>What it tested was whether I could hold an entire system in my head at once knowing that a wrong VPC selection in task two doesn’t just affect task two, it silently threatens everything built on top of it later. Knowing that the real risk in cloud architecture usually isn’t the big obvious failure it’s the small, easy-to miss default sitting quietly in a dropdown, waiting for you to click past it without looking.</p><p>That’s the actual job. Not memorizing what each service does in isolation. Catching the small thing before it becomes five tasks’ worth of consequences.</p><p>#SudoLife — build it, break it, document it, automate it.</p><p><em>#AWS #CloudSupport #DevOps #CapstoneProject #100DaysOfCloud</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3779129b06ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Cloud Isn’t Magic. I Built a Website on AWS to Prove It.]]></title>
            <link>https://medium.com/@tcloudadewale/the-cloud-isnt-magic-i-built-a-website-on-aws-to-prove-it-4922a7d55c40?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/4922a7d55c40</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Fri, 07 Aug 2026 07:48:59 GMT</pubDate>
            <atom:updated>2026-08-07T07:48:59.544Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/515/1*zYgpgYl2567VCvWA-D207Q.png" /><figcaption>This is “the cloud.” Not magic. Just someone else’s very expensive computers.</figcaption></figure><p><em>I rented a computer from Amazon, gave it a brain, and built a live website. <br>Here’s exactly what happened.</em></p><p>Everyone in tech throws around the word “cloud” like it’s obvious.</p><p><em>“Just deploy it to the cloud.”</em> <em>“We’re moving everything to the cloud.”</em> <em>“It’s all in the cloud.”</em></p><p>I nodded along for months. Smiled like I understood. Then one day I sat down, opened AWS, and actually tried to build something — and realized I had no idea what I was doing.</p><p>So I figured it out the hard way. Project by project. Breaking things, fixing things, and refusing to move on until I actually understood what was happening under the hood.</p><p>This is that story.</p><h3>Let’s Kill the Myth First</h3><p>The cloud is not floating above us. It is not abstract. It is not magic.</p><p><strong>The cloud is just someone else’s computers.</strong></p><p>Massive warehouses called data centers packed with thousands of servers, owned by Amazon, Google, Microsoft. Instead of buying your own hardware, you rent theirs. You pay for what you use. You scale up when you need more. You scale down when you don’t.</p><p>That’s the whole secret. The mystery dies right there.</p><p>Now here’s what I built with it.</p><h3>Project One: I Gave a Computer an Address on the Internet</h3><p>Every website needs somewhere to live.</p><p>Before the design. Before the content. Before anyone can type your URL and see anything there has to be a computer, switched on, connected to the internet, ready to respond. That computer is called a server.</p><p>Old way: buy physical hardware, keep it running 24/7, pay for electricity and cooling and maintenance, and pray nothing breaks at 2am.</p><p>New way: rent a virtual computer from Amazon in about four minutes. That’s <strong>Amazon EC2</strong>. That’s what I used.</p><p>But here’s what nobody tells you in the YouTube tutorials:</p><p><strong>You can’t just create the computer. You have to build its entire world first.</strong></p><h3>Building the Neighborhood Before the House</h3><p>Before I touched a single server setting, I had to build a private network for it to live in. AWS calls this a <strong>VPC </strong>— <strong>Virtual Private Cloud</strong>. Think of it as a gated estate. The estate keeps your server protected from the open internet while still letting the right traffic through.</p><p>Inside that estate, three things had to be configured:</p><p><strong>1. An Internet Gateway</strong> The front gate. Without this, nothing gets in or out. No visitors, no traffic, nothing. The server exists but nobody can reach it like a shop with no door.</p><p><strong>2. A Route Table</strong> The road map. A set of directions that tells the network where to send traffic and how to get it there. Skip this and traffic has nowhere to go.</p><p><strong>3. A Security Group</strong> The security guard. Only allows specific types of traffic through in my case, normal web browsing traffic on port 80. Everything else gets blocked automatically.</p><p>I know these matter because I skipped the route table once.</p><p>Blank screen. Thirty minutes of confusion. One missing configuration between me and a working website. Found it. Fixed it. Never forgot it.</p><h3>The Part That Changed How I Think About Infrastructure</h3><p>Once the network was ready, I created the server itself. Chose the operating system, chose the size, set up an access key.</p><p>Then I did something that made me feel like I’d unlocked a cheat code.</p><p>Instead of logging into the server and typing setup commands by hand, I wrote a <strong>User Data script</strong> — a small set of instructions the server runs automatically the moment it boots up. The script:</p><ul><li>Updated the system</li><li>Installed web server software (Apache)</li><li>Downloaded the website files</li><li>Started the website — automatically</li></ul><p>Zero manual work after that. The server configured itself.</p><p>I pasted the public IP address into my browser.</p><p>The website loaded.</p><p>A blank virtual machine nothing on it, had turned itself into a live website based only on instructions I gave it in advance. That moment is when cloud computing stopped being a buzzword and started being something I actually understood.</p><h3>Project Two: I Gave the Website a Brain and a Photo Album</h3><p>A static website that just displays text isn’t that useful. Real websites need to <em>store</em> things — photos, user data, records and update them in real time.</p><p>For this project, I was given an employee directory website. Clean design. Professional layout. Two errors flashing on the screen:</p><ul><li>No place to store employee <strong>photos</strong></li><li>No place to store employee <strong>information</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PzjLn__1fo6fgV3fErmIkA.png" /><figcaption><em>The employee directory app before the fix flagging a missing S3 bucket and a missing DynamoDB table</em></figcaption></figure><p>My job: fix both from scratch.</p><h3>The Photo Album — Amazon S3</h3><p><strong>Amazon S3</strong> is an infinite filing cabinet in the cloud. Store any file — photos, videos, documents, code — and retrieve it instantly from anywhere in the world.</p><p>Here’s what I actually did:</p><ol><li>Created a storage container called a <strong>bucket</strong> — mine was employee-photo-bucket-tc-8306</li><li>Wrote a <strong>bucket policy</strong> — a permissions document defining exactly which programs could access that bucket and what they could do</li><li>Uploaded 10 sample employee photos</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*b9P2oqwzTIUyAziQuA9iIg.png" /><figcaption><em>All 10 employee photos uploaded successfully to the S3 bucket.</em></figcaption></figure><p>The website’s photo page came alive the moment that policy was in place.</p><p>And here’s the thing that will save you hours of debugging one day:</p><p><strong>In AWS, nothing is open by default.</strong></p><p>Every service starts completely locked down. You don’t accidentally expose your data you have to deliberately open specific doors for specific programs. It’s not a bug. It’s the entire security model. Once you internalize this, AWS starts making a lot more sense.</p><h3>The Memory — Amazon DynamoDB</h3><p>Photos were sorted. But the website still couldn’t store names, emails, or job titles. For that <strong>Amazon DynamoDB</strong>, a database built to store and retrieve structured data at any scale.</p><p>I created a table called Employees. Each person became one item. Each detail name, location, email, photo became an attribute.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JKSH6Zi4vwufZaIaSSq6yw.png" /><figcaption><em>The Employees table, created and active in DynamoDB.</em></figcaption></figure><p>Then I tested it properly:</p><ol><li>Added a new employee through the website’s normal interface</li><li>Watched the record appear live inside DynamoDB</li><li>Edited that employee’s location directly in the database</li><li>Refreshed the website the change showed up immediately</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OukmOR7zwM8K2pvTcZsrYA.png" /><figcaption><em>The finished employee directory — live data, live photos, fully connected to S3 and DynamoDB.</em></figcaption></figure><p>The website and database were talking to each other in real time. That’s when it stopped feeling like coursework and started feeling like something I could actually build a career on.</p><h3>What a Modern Website Actually Is</h3><p>Here’s the thing nobody puts in the intro:</p><p><strong>A website isn’t one thing. It’s a system.</strong></p><ul><li>Server (runs the site, responds to visitors) — EC2</li><li>Network (protects the server, controls traffic) — VPC</li><li>File Storage (holds images, videos, documents) — S3</li><li>Database (stores and retrieves structured data) — DynamoDB</li><li>Permissions (controls who accesses what) — IAM Policies</li></ul><p>None of this lives on a single machine in someone’s office. It’s spread across global data centers, available on demand, and capable of scaling from 1 visitor to 1 million without anyone buying a single piece of hardware.</p><p>That’s the cloud. Not magic. <strong>Architecture.</strong></p><h3>Where I Went After This</h3><p>These two projects were the foundation. Since then I’ve kept building:</p><ul><li>A <strong>three-tier AWS architecture</strong> — load balancer sitting in front of an auto-scaling EC2 fleet, backed by a Multi-AZ RDS database</li><li>A full <strong>Terraform project</strong> that provisions an entire AWS stack VPC, EC2, EKS, RDS from a single command</li><li><strong>AWS Systems Manager</strong> automating commands across an entire fleet of servers at once</li></ul><p>Every one of those things connects back to what I learned here. The fundamentals don’t change. Only the scale does.</p><p>If you’re just starting out in cloud don’t wait until you feel ready.</p><p>Open AWS. Build something. Break it. Sit with the confusion until it becomes clarity.</p><p>That’s not the slow way. That’s the only way.</p><p><em>— Tcloud Adewale</em></p><p><em>DevOps &amp; Cloud Engineer | Abuja, Nigeria</em></p><p><em>#SudoLife — Build it. Break it. Document it. Automate it.</em></p><p><em>If this helped you understand something that was fuzzy before clap, follow, or share it with someone who’s been nodding along without really knowing what “the cloud” means. That was me not long ago.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4922a7d55c40" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Quit a Bootcamp Because of One Error. Three Years Later, I Fixed It in an Afternoon.]]></title>
            <link>https://medium.com/@tcloudadewale/i-quit-a-bootcamp-because-of-one-error-three-years-later-i-fixed-it-in-an-afternoon-bfd08a8731d1?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/bfd08a8731d1</guid>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[java]]></category>
            <category><![CDATA[learning-in-public]]></category>
            <category><![CDATA[spring-boot]]></category>
            <category><![CDATA[gradle]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Mon, 30 Mar 2026 09:17:30 GMT</pubDate>
            <atom:updated>2026-03-30T09:17:30.749Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-g_FDbHeHMxFShQRKq5wTw.png" /></figure><p><em>Some errors aren’t just errors. They’re the system telling you it’s time to level up.</em></p><h3>I Quit a Bootcamp Because of One Error. Three Years Later, I Fixed It in an Afternoon.</h3><p><em>Some errors aren’t just errors. They’re the system telling you it’s time to level up.</em></p><p>There’s a particular kind of frustration that comes from hitting a wall you don’t understand.</p><p>Not the kind where you know what’s wrong and can’t fix it. The kind where you don’t even know what you’re looking at — where the error message reads like a foreign language and every fix you try makes things worse.</p><p>That was me in 2023. Fresh into a Java bootcamp I had paid for with my own money, excited to build, locked in and ready — until I hit a Gradle and JDK version conflict that completely stopped me in my tracks.</p><h3>What I Tried (And Why None of It Worked)</h3><p>I didn’t give up immediately. I fought it.</p><p>I reinstalled Java. Changed Gradle versions. Copied fix after fix from Stack Overflow threads written by people who seemed to know exactly what they were doing. I rewrote configuration files. I tried combinations of solutions that made no sense together.</p><p>Nothing worked.</p><p>And eventually, quietly, I made the decision that would sit with me for three years:</p><p><em>I’ll come back to this later.</em></p><p>I didn’t come back. The tab closed. The bootcamp faded. And somewhere in the back of my mind, a small voice started to whisper that maybe this just wasn’t for me.</p><h3>The Promise I Made Myself in 2026</h3><p>I’ve grown a lot as a developer since 2023. New tools, new projects, new ways of thinking about systems. But that unfinished bootcamp never fully left me alone.</p><p>So I made a real promise not the kind you make and quietly forget:</p><p><em>Finish the bootcamp. Deploy every project. Face every challenge. No exceptions.</em></p><p>I restarted from scratch. This time, I wasn’t just going to follow tutorials and copy commands. I wanted to actually understand the system underneath everything.</p><p>The first few weeks went smoothly. Then came the project that had been waiting for me.</p><p>Same project. Same error. Right on cue.</p><p>This time, I didn’t spiral. I smiled because I already knew something I didn’t know three years ago:</p><p><em>This isn’t just a bug. This is a system problem.</em></p><h3>What Was Actually Wrong — Three Layers Deep</h3><p>The first thing I did differently was refuse to treat it as a single issue. I pulled the error apart until I could see exactly what was broken and why.</p><p>What I found were three distinct layers of incompatibility stacked on top of each other.</p><p><strong>Layer 1: A broken Gradle wrapper</strong></p><p>The Gradle wrapper itself was outdated old enough that its internal APIs had changed and it could no longer even regenerate itself cleanly. Any fix attempted on top of this foundation was going to fail.</p><p><strong>Layer 2: A Spring Boot version conflict</strong></p><p>The project was configured with Spring Boot 2.2.2 — a version that simply isn’t compatible with modern Gradle. Everything from dependency resolution to build behavior was misaligned because the two had drifted too far apart.</p><p><strong>Layer 3: A Java migration issue hiding in the code</strong></p><p>Running Java 17 meant that javax.annotation — which the original code still depended on had been removed from the JDK entirely. The codebase was referencing something that no longer existed in the environment it was running in.</p><p>Three separate problems. All of them invisible until I looked at the system as a whole rather than chasing individual error messages.</p><h3>The Fix — Systematic, Not Guesswork</h3><p>Once I understood the root cause, the solution became straightforward. Not easy but clear.</p><p><strong>Step 1: Reset Gradle completely</strong></p><p>I deleted the broken wrapper files entirely and rebuilt from a clean foundation using Gradle 8.4. No patching. No partial fixes. A clean slate.</p><p><strong>Step 2: Align the entire ecosystem</strong></p><p>The core principle here was version harmony. I upgraded everything to work together as a coherent system:</p><ul><li>Java 17</li><li>Gradle 8.4</li><li>Spring Boot 3.2.3</li></ul><p><strong>Step 3: Fix the breaking code changes</strong></p><p>With Spring Boot 3 came the full migration from javax to jakarta. Every reference had to be updated:</p><pre>// Before<br>import javax.annotation.PostConstruct;<br><br>// After<br>import jakarta.annotation.PostConstruct;</pre><p>And the required dependency added to build.gradle:</p><pre>implementation &#39;jakarta.annotation:jakarta.annotation-api:2.1.1&#39;</pre><p><strong>Step 4: Run the build</strong></p><p>With every layer addressed, I ran the command I had been afraid of for three years:</p><p>./gradlew clean build<br>```<br>```<br>BUILD SUCCESSFUL</p><p>I stared at the screen for longer than necessary.</p><h3>What This Actually Taught Me</h3><p>The technical fix mattered. But the real lesson was something deeper.</p><p>Most errors that stop developers especially early on aren’t actually bugs in the traditional sense. They are misaligned systems. Different tools, different versions, different assumptions about the environment, all trying to work together without a shared foundation.</p><p>When I failed in 2023, it wasn’t because I wasn’t smart enough or persistent enough. It was because I didn’t yet understand build tools, dependency management, or version compatibility. I was trying to fix symptoms without understanding the system producing them.</p><p>Now I do. And that changes everything.</p><p>The difference between 2023 me and now isn’t confidence or motivation it’s mental model. Back then, an error meant frustration, then paralysis, then quitting. Now an error means investigation, decomposition, and a fix. Same errors. Different developer.</p><h3>What’s Next</h3><p>This is one project down in a bootcamp I’m committed to finishing completely — every module, every project, every deployment documented.</p><p>The goal isn’t just the certificate, though I’m earning that too. The goal is to become the kind of developer who doesn’t run from complexity — who looks at a broken system, understands it, and fixes it.</p><p>The project that once made me quit is now the one that proved I’ve grown.</p><p>No more closed tabs. No more <em>“I’ll come back to this later.”</em></p><p><em>Follow along there’s a lot more building to do.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bfd08a8731d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Thought I Could Install Linux on Anything. Then I Met a Chromebook.]]></title>
            <link>https://medium.com/@tcloudadewale/i-thought-i-could-install-linux-on-anything-then-i-met-a-chromebook-0c5d086a6d52?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/0c5d086a6d52</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[chromebook-security]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Thu, 19 Mar 2026 06:34:42 GMT</pubDate>
            <atom:updated>2026-03-19T06:36:02.414Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Uv2nXWSH_rHj_l3PNiLUWw.png" /></figure><p><strong>I Thought I Could Install Linux on Anything. Then I Met a Chromebook.<br></strong><em>By Abidemi Adewale | DevOps · Cloud · Cybersecurity</em></p><p>I’ve broken systems on purpose. I’ve rebuilt them from scratch. I’ve fixed bootloaders at 2AM when most people were asleep. So when a Chromebook landed in my hands, I looked at it the way any self-respecting DevOps engineer would as a challenge.</p><p>My goal was simple: strip out ChromeOS, install a full Linux distribution, and turn this thing into a proper development and security testing machine.</p><p><em>Simple. Clean. Straightforward.</em></p><p><strong>I was completely wrong.</strong></p><h3>The Plan Looked Good on Paper</h3><p>I had worked with Linux environments before Ubuntu, Kali, terminal all day. I knew what I was doing. The plan was straightforward:</p><ul><li>Enable Developer Mode on the Chromebook</li><li>Modify the firmware to allow custom OS installation</li><li>Flash a full Linux distribution</li><li>Build a proper dev and ethical hacking environment</li></ul><p>Step one went fine. Developer Mode enabled. Commands checked. Guides cross-referenced. Everything looked correct. And then the system just… refused.</p><h3>The Wall I Didn’t See Coming</h3><p>I stared at my terminal like it had personally disrespected me. Every command was right. Every configuration was correct. But the firmware modification was being blocked hard.</p><p>That’s when I went deeper into the Chromebook’s architecture and discovered something I hadn’t expected:</p><p><strong>The write-protect screw.</strong></p><p>Deep inside the Chromebook’s hardware sits a small physical screw that locks the firmware from being modified. It’s not a software setting. It’s not a configuration you can override with a clever command. It’s a piece of metal that physically says:</p><p><strong><em>“Not today.”</em></strong></p><h3>What the Write-Protect Screw Actually Does</h3><p>As long as this screw is in place, you cannot:</p><ul><li>Flash custom firmware</li><li>Replace ChromeOS with another operating system</li><li>Modify verified boot settings at the hardware level</li></ul><p>Google designed Chromebooks with security as a hardware-level priority not just software. The verified boot system, the controlled firmware, the physical write protection it’s all intentional. For the average user, this is actually a great security feature. For someone trying to repurpose the device? It’s a full stop.</p><p>To proceed, I would have needed to physically open the Chromebook and remove the screw then flash the firmware, then install Linux. I made the decision not to open the device at that time. And just like that the project failed.</p><h3>What I Actually Learned</h3><p>Here’s the thing about failure in tech it teaches you more than success ever could.</p><p><strong>1. Hardware security is not theoretical</strong></p><p>We spend so much time in cybersecurity thinking about software vulnerabilities firewalls, encryption, access control. This experience was a real-world reminder that hardware enforces its own security policies. No bypass. No workaround from the terminal. Physical security is a layer that exists completely outside your keyboard.</p><p><strong>2. Know your hardware before you start</strong></p><p>Different Chromebook models handle write protection differently. Some use a screw, some use a jumper, some newer models use a software flag. Had I researched my specific model before starting, I would have known what I was walking into. Lesson: reconnaissance matters even when the target is your own device.</p><p><strong>3. An incomplete project is not a wasted project</strong></p><p>I didn’t install Linux. But I now understand Chromebook architecture, verified boot systems, hardware-level firmware protection, and the relationship between physical security and software security better than I ever would have from reading alone. That knowledge is real. That knowledge stays.</p><h3>What I’ll Do Differently Next Time</h3><ol><li>Research the exact Chromebook model and its write-protect mechanism before starting</li><li>Prepare properly for hardware modification with the right tools</li><li>Safely remove the write-protect screw following the model-specific guide</li><li>Flash custom firmware using MrChromebox’s firmware utility</li><li>Then install the Linux distribution of choice</li></ol><h3>Final Thoughts</h3><p>This wasn’t the article I planned to write. I planned to write about successfully installing Linux on a Chromebook. Instead I’m writing about a tiny screw that stopped me cold.</p><p><strong>And honestly? This is the better article.</strong></p><p>Because real engineering isn’t about always succeeding. It’s about understanding WHY something didn’t work and building the knowledge to approach it better next time.</p><p><em>In tech, every obstacle is just another layer of the system waiting to be understood. 💙</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0c5d086a6d52" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[CI/CD Pipeline from Scratch: Flask + Docker + GitHub Actions]]></title>
            <link>https://medium.com/@tcloudadewale/ci-cd-pipeline-from-scratch-flask-docker-github-actions-5f3070d82a78?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f3070d82a78</guid>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[python]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[ci-cd-pipeline]]></category>
            <category><![CDATA[docker]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Mon, 02 Mar 2026 01:40:59 GMT</pubDate>
            <atom:updated>2026-03-02T01:40:59.136Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XnCH2f9t4AJgwJV5sBSQMg.png" /></figure><p><em>Flask + Docker + GitHub Actions — a complete walkthrough with every mistake I made along the way</em></p><p><strong>Abidemi Adewale</strong> · DevOps / Cloud Engineer · AltSchool Africa Graduate</p><p>Most DevOps tutorials show you the happy path.</p><p>You follow the steps, everything works, and you close the tab feeling like an engineer.</p><p>That’s not how this went.</p><p>I spent days debugging Docker daemon issues, pushing the wrong image names, accidentally committing 839 unnecessary files to GitHub, and watching my pipeline fail three times before it finally turned green.</p><p>This is the real story every mistake, every fix, every lesson.</p><p>By the end of this article, you’ll have a fully working CI/CD pipeline that automatically tests, builds, and pushes your Docker image every time you push code to GitHub. 🚀</p><h3>What We’re Building</h3><p>Here’s the complete pipeline we’ll build:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/543/1*CvSulWghHH9LnbqExiFG8w.png" /></figure><p><strong>Tech Stack:</strong></p><ul><li>Python 3.11 + Flask — the application</li><li>Pytest — automated testing</li><li>Docker — containerization</li><li>GitHub Actions — CI/CD automation</li><li>Docker Hub — image registry</li><li>Ubuntu Linux — development environment</li></ul><h3>Step 1: Build the Flask Application</h3><p>We start with a simple Flask app. Nothing fancy — just two endpoints that prove the app is running and healthy. In a real project, this would be your actual application.</p><p><strong>app.p</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*2e4lHwoySJ8DTlGmBfUpFQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*0JXf7YilPAywlG8N1Tfraw.png" /></figure><p><strong>requirements.txt</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*6NxozwuniADPvzLZslwJ_g.png" /></figure><h3>Step 2: Write Automated Tests</h3><p>This is the step most beginners skip. Don’t. Tests are the heart of CI/CD they’re the reason you can push code with confidence.</p><p><strong>test_app.py</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*UO9vvSfC5t287wlq96mFjg.png" /></figure><p>Run them locally first to make sure they pass:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*ADohe2i-73s1_C3Om11fIw.png" /></figure><p>You should see:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*qhgX6bs0mF2p0u3Lt4zhRA.png" /></figure><h3>Step 3: Containerize with Docker</h3><p>The Dockerfile tells Docker how to package your application into a portable container.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*efCdAnKnQLQvqlqK6lOGNg.png" /><figcaption><strong>Dockerfile</strong></figcaption></figure><blockquote><em>Notice that requirements.txt is copied before the rest of the application code. This is a Docker layer caching optimization — if your dependencies don’t change, Docker reuses the cached layer and the build is much faster.</em></blockquote><p>Build and run locally to verify:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*3UkdBC4Fqrm0i5AUtvR6uA.png" /></figure><p>Open your browser at <a href="http://localhost:5000/">http://localhost:5000</a> — you should see your JSON response.</p><h3>❌ Mistake I Made: Docker Daemon Was Masked</h3><p>When I ran docker build, I got:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*oZUuXbwwgFSA3LC6g1gM7Q.png" /></figure><p>Then when I tried to start Docker:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/1*r-JVeTZafVDDc0OniEhu5g.png" /></figure><p>Fix:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/542/1*Wi_UPyxk3Ded6EJ02Qhn1g.png" /></figure><blockquote><em>A masked service is one that has been explicitly disabled at the systemd level. Unmasking removes that restriction so the service can be started normally.</em></blockquote><h3>Step 4: Build the GitHub Actions Pipeline</h3><p>This is the magic. Create this file at .github/workflows/deploy.yml in your repository:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*-zU4c5yn2oQGeqGG_sVPQA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*wRk_1loqz-XUgrGoHJa4fw.png" /></figure><blockquote><em>The ${{ secrets.DOCKER_USERNAME }} syntax tells GitHub Actions to read from the repository’s encrypted secrets — never hardcode credentials in your workflow file.</em></blockquote><h3>❌ Mistake I Made: Missing Docker Hub Secrets</h3><p>My pipeline failed with:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*I188K_gr48VVTJe6z8xrCA.png" /></figure><p>I had written the workflow but hadn’t added the secrets to GitHub yet. Here’s how to add them:</p><ul><li>Go to your GitHub repo → Settings → Secrets and variables → Actions</li><li>Click New repository secret</li><li>Add DOCKER_USERNAME with your Docker Hub username</li><li>Add DOCKER_PASSWORD with your Docker Hub password</li></ul><h3>❌ Mistake I Made: Wrong Docker Hub Username</h3><p>Even after adding secrets, the pipeline failed with:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/1*lAnj3LyvoqzQVwH9bfG7ng.png" /></figure><p>The workflow was pushing to tcloudadewale/devops-app but my Docker Hub username is tcloudguy. Always make sure the image name in your workflow matches your actual Docker Hub username exactly.</p><h3>Step 5: Push to GitHub and Watch It Run</h3><p>Initialize your repo and push:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/530/1*rEvw4XsN-8q2_w4u2UisEQ.png" /></figure><blockquote><em>GitHub no longer accepts passwords for Git operations. You need a Personal Access Token (PAT). Go to GitHub → Settings → Developer settings → Personal access tokens → Generate new token. Check the repo and workflow scopes.</em></blockquote><h3>❌ Mistake I Made: Committing venv to Git</h3><p>My first commit included 839 files from the venv folder! Always add venv/ to your .gitignore before your first commit:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*422FIh8jd_x7Q5GaB1Wx9g.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*dDfGDRqUjbvUoT5RCeBA-w.png" /></figure><p>If you already committed venv by mistake:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/539/1*XEEm8PkUVVLi3-K3DSE1Ww.png" /></figure><h3>The Green Pipeline 🟢</h3><p>After fixing all those mistakes, I pushed my code and watched the Actions tab. Every step turned green one by one:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/533/1*14iPrKWf_pSf0b2BlZNuOQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*hodhBt5m5OqVCtOcCcfU0g.png" /></figure><p>That feeling when every step goes green? That’s why people do DevOps.</p><h3>What This Project Taught Me</h3><h3>1. Tests are not optional in CI/CD</h3><p>The whole point of a pipeline is that you can push code with confidence. Without tests, you’re just automating deployment of potentially broken code.</p><h3>2. Secrets management is a real engineering discipline</h3><p>Never hardcode credentials. Ever. GitHub Actions secrets, environment variables, and tools like HashiCorp Vault exist for a reason. One leaked credential can compromise an entire system.</p><h3>3. Read the logs carefully</h3><p>Every pipeline failure tells you exactly what went wrong if you read carefully. ‘denied: requested access to the resource is denied’ told me the username was wrong. ‘Username and password required’ told me the secrets were missing. The logs don’t lie.</p><h3>4. .gitignore is your first line of defense</h3><p>Set it up before your first commit. Always. Learn from my 839-file mistake.</p><h3>5. Break things. Fix things. Document things.</h3><p>I broke Docker, the pipeline, and git all in one project. And I fixed every single one. That’s where the real learning happens. Not in tutorials. In the debug logs at 2am.</p><h3>What’s Next</h3><ul><li>Phase 2: Infrastructure as Code with Terraform provisioning cloud infrastructure automatically</li><li>Phase 3: Monitoring + Logging with Prometheus and Grafana</li><li>Add SSH deployment to a live cloud VM to complete the pipeline</li><li>Explore secrets management with HashiCorp Vault</li></ul><h3>Final Thoughts</h3><p>Building your first CI/CD pipeline is one of those engineering milestones that changes how you think about software delivery. Once you’ve seen code automatically tested, built, and pushed without you touching a button you can’t go back to doing it manually.</p><p>The mistakes I made are not failures. They’re the curriculum. Every error message is a lesson. Every fix is a skill.</p><p>Now go build yours. 🐧🚀</p><p>🔗 GitHub Repository: github.com/TcloudAdewale/devops-cicd-project</p><p>🐳 Docker Hub Image: hub.docker.com/r/tcloudguy/devops-app</p><p><em>Tags: DevOps · CI/CD · Docker · GitHub Actions · Python · Flask · Linux · TechAfrica</em></p><p>Written by Abidemi Adewale — DevOps / Cloud Engineer | AltSchool Africa Graduate | CS Student @ University of the People</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f3070d82a78" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How I Fixed a Broken Linux Bootloader at 2AM]]></title>
            <link>https://medium.com/@tcloudadewale/how-i-fixed-a-broken-linux-bootloader-at-2am-1fe52f67cfce?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/1fe52f67cfce</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ubuntu]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[devops]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Sun, 22 Feb 2026 22:21:03 GMT</pubDate>
            <atom:updated>2026-02-22T22:21:03.363Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NlsRIJIrQ1UQ6leD3537pA.png" /></figure><p><strong>How I Fixed a Broken Linux Bootloader at 2AM</strong></p><p><em>A complete GRUB/EFI recovery walkthrough — with the exact commands that saved my system</em></p><p><strong>Abidemi Adewale</strong> · DevOps &amp; Cloud Engineer · AltSchool Africa Graduate</p><p>It was late at night.</p><p>I hit the power button, expecting the familiar Ubuntu login screen.</p><p>Instead, I got this:</p><pre>error: no such partition.<br>Entering rescue mode...<br>grub rescue&gt; _</pre><p>My stomach dropped.</p><p>The bootloader was gone. My system wouldn’t boot. All my work, my projects, my configurations — locked behind a black screen and a blinking cursor.</p><p>Most people would have reinstalled Ubuntu and started from scratch.</p><p>I didn’t. Not because I was brave but because I was stubborn, and I knew there had to be a way.</p><p>Four hours later, my system was back. Fully recovered. No data lost.</p><p>This is the exact story of how I did it every command, every mistake, every lesson.</p><h3>What Actually Happened</h3><p>Before I tell you how I fixed it, let me explain what broke.</p><p>I had been experimenting with disk partitions running multiple Linux distributions on the same machine. During a routine operation, I accidentally corrupted the EFI System Partition (ESP). This is the small partition that contains the bootloader files the very first thing your computer looks for when it starts up.</p><p>Without a working EFI partition, GRUB (Grand Unified Bootloader) the software responsible for loading Linux had no entry point. The system dropped me into grub rescue mode, a minimal emergency shell with almost no commands available.</p><blockquote><em>The EFI System Partition (ESP) is typically mounted at /boot/efi and contains bootloader files for all operating systems on the machine. If it gets corrupted or its entries are deleted, the system cannot boot.</em></blockquote><p>Understanding the problem is half the battle. Now let’s fix it.</p><h3>What You Need</h3><ul><li>A USB drive (8GB or more)</li><li>Ubuntu ISO — download from ubuntu.com</li><li>Rufus (Windows) or Balena Etcher (Linux/Mac) to flash the ISO</li><li>The broken Linux machine</li><li>Patience</li></ul><h3>Step 1: Boot Into a Live USB Environment</h3><p>Since the machine won’t boot normally, we need to boot from an external source. Flash the Ubuntu ISO to your USB drive and boot from it.</p><p><strong>How to boot from USB:</strong></p><ul><li>Insert the USB drive</li><li>Restart the machine</li><li>Press F2, F12, DEL, or ESC (depending on your machine) to enter the BIOS/boot menu</li><li>Select the USB drive as the boot device</li><li>Choose ‘Try Ubuntu’ (not Install)</li></ul><p>You’re now running a live Ubuntu session. The broken system is still on your hard drive — we’re going to reach into it and fix it from the outside.</p><h3>Step 2: Identify Your Partitions</h3><p>Open a terminal in the live Ubuntu session. First, we need to find where your Linux installation lives on the disk.</p><pre>sudo fdisk -l</pre><p>This lists all disks and partitions. Look for your main disk — usually /dev/sda or /dev/nvme0n1 on newer machines. You’re looking for two key partitions:</p><ul><li>Your EFI System Partition — usually small (100–512MB), type ‘EFI System’</li><li>Your Linux root partition — larger, type ‘Linux filesystem’</li></ul><p>You can also use this command for a cleaner view:</p><pre>lsblk -f</pre><blockquote><em>On my machine, the EFI partition was /dev/sda1 and the root partition was /dev/sda2. Yours may be different — always verify before proceeding.</em></blockquote><h3>Step 3: Mount the Partitions</h3><p>Now we mount the broken system’s partitions so we can work inside them. Replace /dev/sda2 and /dev/sda1 with your actual partition identifiers.</p><p><strong>Mount the root partition:</strong></p><pre>sudo mount /dev/sda2 /mnt</pre><p><strong>Mount the EFI partition:</strong></p><pre>sudo mount /dev/sda1 /mnt/boot/efi</pre><p><strong>Mount the system directories (critical for chroot to work):</strong></p><pre>sudo mount --bind /dev /mnt/dev<br>sudo mount --bind /proc /mnt/proc<br>sudo mount --bind /sys /mnt/sys<br>sudo mount --bind /run /mnt/run</pre><p>These bind mounts give the chroot environment access to the live system’s device files, process information, and kernel interfaces — without them, commands inside chroot will fail.</p><h3>Step 4: chroot Into the Broken System</h3><p>This is the key step. chroot (change root) lets us enter the broken system as if we had booted into it normally. Every command we run after this will execute inside the broken installation.</p><pre>sudo chroot /mnt</pre><p>Your terminal prompt will change. You are now inside your broken system. From here, we can reinstall and repair GRUB.</p><blockquote><em>chroot is one of the most powerful tools in a Linux administrator’s toolkit. It changes the apparent root directory for the current process — effectively letting you operate inside a different Linux installation without rebooting into it.</em></blockquote><h3>Step 5: Reinstall GRUB</h3><p>Now we reinstall the GRUB bootloader. This rewrites the bootloader files to the EFI partition and registers the boot entry with the firmware.</p><p><strong>First, update package lists:</strong></p><pre>apt update</pre><p><strong>Reinstall GRUB for EFI systems:</strong></p><pre>grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=ubuntu</pre><p>If your system uses BIOS (not EFI), use this instead:</p><pre>grub-install /dev/sda</pre><p>Then update the GRUB configuration file:</p><pre>update-grub</pre><p>You should see output listing the kernels and operating systems GRUB found. If it finds your Ubuntu installation, you’re almost there.</p><h3>Step 6: Exit chroot and Reboot</h3><p>Exit the chroot environment and unmount everything cleanly:</p><pre><br>exit<br>sudo umount /mnt/dev<br>sudo umount /mnt/proc<br>sudo umount /mnt/sys<br>sudo umount /mnt/run<br>sudo umount /mnt/boot/efi<br>sudo umount /mnt</pre><p>Remove the USB drive and reboot:</p><pre>sudo reboot</pre><p>Watch the screen. If everything worked, GRUB will load and your system will boot normally.</p><p>Mine did. After four hours of debugging, the login screen appeared.</p><p>I sat back and exhaled.</p><h3>What This Experience Taught Me</h3><h3>1. Read the error message — really read it</h3><p>‘error: no such partition’ told me exactly what was wrong. The bootloader couldn’t find its partition. I just had to understand what that meant before I could fix it.</p><h3>2. The terminal doesn’t lie</h3><p>Every command gave me information. fdisk -l showed me the partition layout. grub-install confirmed what it was writing. update-grub told me what it found. I learned to read output carefully instead of just running commands and hoping for the best.</p><h3>3. Understanding &gt; memorizing</h3><p>I didn’t memorize these commands before the incident. I learned them by needing them. Understanding why each step exists — why we bind-mount /dev, why chroot works the way it does — made the process logical, not magical.</p><h3>4. Break things on purpose</h3><p>After I recovered my system, I set up a VM and deliberately broke the bootloader again — just to practice the recovery. The second time took 20 minutes. The third time, 10. Now I could do it in my sleep.</p><blockquote><em>The best way to learn Linux administration is to break things in a safe environment and fix them. Set up a VM. Experiment freely. That’s where real skill is built.</em></blockquote><h3>Quick Reference: Full Command Sequence</h3><p>For those who need it fast — here’s the complete recovery sequence:</p><pre># Boot from live USB, open terminal<br><br># 1. Identify partitions<br>sudo fdisk -l<br>lsblk -f<br><br># 2. Mount root and EFI partitions<br>sudo mount /dev/sda2 /mnt<br>sudo mount /dev/sda1 /mnt/boot/efi<br><br># 3. Bind-mount system directories<br>sudo mount --bind /dev /mnt/dev<br>sudo mount --bind /proc /mnt/proc<br>sudo mount --bind /sys /mnt/sys<br>sudo mount --bind /run /mnt/run<br><br># 4. Enter the broken system<br>sudo chroot /mnt<br><br># 5. Reinstall GRUB (EFI system)<br>apt update<br>grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=ubuntu<br>update-grub<br><br># 6. Exit and clean up<br>exit<br>sudo umount /mnt/dev /mnt/proc /mnt/sys /mnt/run /mnt/boot/efi /mnt<br>sudo reboot</pre><h3>Final Thoughts</h3><p>Linux will break on you. Bootloaders will fail. Partitions will get corrupted. Systems will refuse to start.</p><p>That’s not a bug in your journey — that’s the journey.</p><p>Every engineer who works seriously with Linux has a story like this. The difference between beginners and experienced engineers isn’t that experienced engineers never break things. It’s that they know how to fix what they break.</p><p>So the next time your terminal throws an error that makes your heart sink breathe, read carefully, and start working through it systematically.</p><p>You’ve got this. 🐧</p><p><em>Tags: Linux · DevOps · SysAdmin · Ubuntu · GRUB · Bootloader · TechAfrica · CloudEngineering · Cybersecurity</em></p><p>Written by Abidemi Adewale — DevOps &amp; Cloud Engineer | AltSchool Africa Graduate | CS Student @ University of the People</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1fe52f67cfce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Mastering the Machine: Android, Linux, and Taking Back Control in 2026]]></title>
            <link>https://medium.com/@tcloudadewale/mastering-the-machine-android-linux-and-taking-back-control-in-2026-b27f9a21c091?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/b27f9a21c091</guid>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Wed, 14 Jan 2026 21:36:20 GMT</pubDate>
            <atom:updated>2026-01-14T21:36:20.536Z</atom:updated>
            <content:encoded><![CDATA[<p>As we move into 2026, modern computing is increasingly defined by restriction. Devices ship locked down, systems default to read-only, and users are expected to adapt their workflows around imposed limits rather than question them. Messages like “System Locked” or “No Root Access” are treated as final, not negotiable.</p><p>For most users, this is acceptable. For those of us who care about how systems actually work, it isn’t.</p><p>This week, I went deep into Android virtualization and built a fully rooted, custom-configured BlissOS environment. What started as simple troubleshooting quickly turned into a practical lesson about control, defaults, and ownership in modern systems.</p><h4><strong>Breaking the Default: Reclaiming Read–Write Access</strong></h4><p>The most common failure in modern systems isn’t a bug — it’s accepting the default configuration. Many operating systems now ship with restrictive, read-only designs that prioritize stability and control over flexibility.</p><p>By manually configuring my BlissOS installation for full read–write access, I moved from being a passive user of the system to an active owner of it. This single step unlocked the ability to modify system behavior, apply fixes properly, and experiment without artificial limits.</p><p>Without write access, you’re not really administering a system — you’re operating inside boundaries defined by someone else.</p><p><strong>Remember</strong>: <em>Control begins where write access is allowed.</em></p><h4><strong>Solving the Tablet Mode Problem</strong></h4><p>One of the most frustrating issues in Android virtualization is how applications detect the environment they’re running in. Apps like WhatsApp frequently default to tablet mode in virtual setups, limiting functionality and breaking expected workflows.</p><p>Instead of working around the limitation, I chose to understand it.</p><p>By adjusting Developer Options specifically forcing a Smallest Width value of 411 I changed how the system identified itself to applications. That single configuration shift was enough to trigger full phone-mode behavior inside a virtual environment.</p><p>This wasn’t a gimmick or a shortcut. It was a reminder that many limitations are policy decisions, not technical impossibilities.</p><h4><strong>Redefining the Environment</strong></h4><p>Once filesystem access and device identity were under control, the focus shifted from installation to usability. Permissions, system intent, and application behavior began to align with how I actually needed the system to work.</p><p>At that point, the setup stopped feeling like a constrained virtual tablet and started behaving like a real, daily-use workstation.</p><p>The success wasn’t just that BlissOS was running. The success was that the machine was behaving on my terms.</p><h4><strong>Why the Command Line Still Matters</strong></h4><p>In an era of sealed devices and managed experiences, problem-solving at the command line remains one of the few ways to truly understand the systems we depend on.</p><p>Linux, Android, and open tooling still reward curiosity, persistence, and a willingness to question defaults. Logs tell stories. Errors teach patterns. Reboots, failures, and retries are part of the process — not signs of incompetence.</p><p>The lesson from this experience is simple: control isn’t given, it’s earned.</p><p>And the moment you stop pushing back against imposed limits, you quietly accept them as normal.</p><p>For builders, tinkerers, and anyone who believes technology should work for the user, that’s a cost worth paying attention to…</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b27f9a21c091" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Git and GitHub? A Beginner’s Guide]]></title>
            <link>https://medium.com/@tcloudadewale/why-git-and-github-a-beginners-guide-d180735b2ad8?source=rss-d2f790969a2d------2</link>
            <guid isPermaLink="false">https://medium.com/p/d180735b2ad8</guid>
            <dc:creator><![CDATA[SudoLife]]></dc:creator>
            <pubDate>Tue, 18 Mar 2025 11:43:11 GMT</pubDate>
            <atom:updated>2025-03-18T11:43:11.779Z</atom:updated>
            <content:encoded><![CDATA[<h3>Introduction</h3><p>Git is the most widely used version control system, with over 70% of developers relying on it. Whether you’re working solo or as part of a team, Git makes collaboration easier, tracks changes efficiently, and provides a way to revert to previous versions of your project. In this article, we will explore the importance of Git, the role of GitHub, and essential Git commands for beginners.</p><h3>Why Git?</h3><p>Here are some key reasons why Git is essential for developers:</p><ul><li><strong>Seamless collaboration</strong> — Developers can work together from anywhere in the world.</li><li><strong>Version history tracking</strong> — Every change made to the project is recorded, making it easy to track progress and rollback changes if needed.</li><li><strong>Revert to previous versions</strong> — Developers can restore an earlier version of the project in case of mistakes or bugs.</li></ul><h3>What is GitHub?</h3><p>Many people confuse Git with GitHub, but they are not the same.</p><ul><li><strong>Git</strong> is a distributed version control system that helps track changes in source code.</li><li><strong>GitHub</strong> is a platform that provides tools built around Git, making collaboration and code hosting easier.</li><li>GitHub is the largest host of code in the world and has been owned by Microsoft since 2018.</li></ul><h3>Focus of This Tutorial</h3><p>In this tutorial, we will focus on using Git in combination with GitHub to manage and collaborate on projects effectively.</p><h3>Basic Git Commands for Beginners</h3><h3>1. Setting Up Git</h3><p>Before using Git, you need to configure it with your details:</p><pre>git config --global user.name &quot;Your Name&quot;<br>git config --global user.email &quot;your.email@example.com&quot;</pre><h3>2. Initializing a Git Repository</h3><p>To start tracking a project with Git:</p><pre>git init</pre><p>This creates a new Git repository in your project folder.</p><h3>3. Cloning an Existing Repository</h3><p>To copy a remote repository to your local machine:</p><pre>git clone &lt;repository-url&gt;</pre><h3>4. Checking Repository Status</h3><p>To check the current state of your files:</p><pre>git status</pre><h3>5. Adding Files to Staging Area</h3><p>Before committing, you need to stage the files:</p><pre>git add &lt;file-name&gt;   # Adds a specific file<br>git add .             # Adds all files</pre><h3>6. Committing Changes</h3><p>After staging, commit your changes with a message:</p><pre>git commit -m &quot;Your commit message&quot;</pre><h3>7. Viewing Commit History</h3><p>To see a list of previous commits:</p><pre>git log</pre><h3>8. Creating and Switching Branches</h3><p>To create a new branch:</p><pre>git branch &lt;branch-name&gt;</pre><p>To switch to another branch:</p><pre>git checkout &lt;branch-name&gt;</pre><p>or</p><pre>git switch &lt;branch-name&gt;</pre><h3>9. Pushing Changes to GitHub</h3><p>To send committed changes to a remote repository:</p><pre>git push origin &lt;branch-name&gt;</pre><h3>10. Pulling Latest Changes</h3><p>To fetch and merge changes from a remote repository:</p><pre>git pull origin &lt;branch-name&gt;</pre><h3>11. Merging Branches</h3><p>To merge a branch into the current branch:</p><pre>git merge &lt;branch-name&gt;</pre><h3>12. Reverting to a Previous Commit</h3><p>To undo changes and go back to a previous commit:</p><pre>git checkout &lt;commit-id&gt;</pre><h3>Conclusion</h3><p>Git and GitHub are essential tools for developers, enabling efficient version control, collaboration, and project management. By learning the basic commands covered in this guide, you can start leveraging Git to manage your projects effectively. Stay tuned for more in-depth Git tutorials as we continue our DevOps journey!</p><p>If you found this guide helpful, feel free to share and leave your thoughts in the comments below. Happy coding! 🚀</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d180735b2ad8" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>