<?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 Saharia Hassan Safin on Medium]]></title>
        <description><![CDATA[Stories by Saharia Hassan Safin on Medium]]></description>
        <link>https://medium.com/@sahariahassansafin?source=rss-a0ed3add2c50------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*v5ungSTUIJgYNW4I4lXskg.jpeg</url>
            <title>Stories by Saharia Hassan Safin on Medium</title>
            <link>https://medium.com/@sahariahassansafin?source=rss-a0ed3add2c50------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 00:55:54 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sahariahassansafin/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[I Made My GitHub Public From Day One — Worst Decision That Became the Best One]]></title>
            <link>https://javascript.plainenglish.io/i-made-my-github-public-from-day-one-worst-decision-that-became-the-best-one-7e00b75035e5?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/7e00b75035e5</guid>
            <category><![CDATA[100daysofcode]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[build-in-public]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[ec]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Tue, 23 Jun 2026 17:11:00 GMT</pubDate>
            <atom:updated>2026-10-25T16:56:04.449Z</atom:updated>
            <content:encoded><![CDATA[<h4>Every messy first commit is still sitting there. I’m glad it is.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rso0XPtL6hfEz2Jfj-ufew.png" /><figcaption>GitHub profile page on laptop screen, green contribution graph visible, dark theme, desk setup, soft ambient light, no text overlay, 16:9</figcaption></figure><blockquote><em>When I created my GitHub account, I didn’t think about whether to make my repositories public or private. I just made everything public by default, mostly because that’s what the tutorial I was following told me to do. I had no idea that decision would mean every embarrassing, broken, barely-functional piece of code I’d ever write was about to become permanently visible to anyone who looked.</em></blockquote><h3>The Decision I Didn’t Really Make</h3><p>Looking back, “decision” is generous. I didn’t weigh pros and cons. I followed a setup guide that said to make your repo public, clicked the button, and moved on with my day. I was focused on getting my first Beecrowd solution pushed up, not on the long-term implications of what would be visible there.</p><p>It took a few months before the weight of that decision actually hit me.</p><p>I’d push a solution to a problem, feel decent about it, and move on. Then weeks later, I’d go back to check something and look at code I’d written when I genuinely didn’t understand what I was doing. Variable names like x, temp, a1, a2. Logic that worked but made no sense if you tried to read it as a story. Comments that were either nonexistent or embarrassingly basic, the kind you write when you&#39;re explaining something to yourself because you don&#39;t trust your own understanding yet.</p><p>And all of it was just sitting there. Public. Visible to anyone — a recruiter, a more experienced student, a stranger browsing GitHub for inspiration — who happened to click on my profile.</p><h3>The Specific Discomfort of Being Seen Learning</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YLFkgb7aevvmfGX0-xm29A.png" /><figcaption>Person looking at old code on screen, slightly uncomfortable expression implied through posture, dark room, contemplative mood, no faces</figcaption></figure><p>There’s a particular kind of vulnerability in this that’s hard to describe if you haven’t experienced it. It’s not the same as failing a test privately, where only you know the result. It’s not the same as messing something up in a closed environment where the evidence disappears.</p><p>This was different. Every step of my learning process — including the steps where I clearly didn’t know what I was doing yet — was sitting in a permanent, dated, timestamped record that anyone could browse through chronologically and watch me figure things out in real time.</p><p>I remember feeling genuinely exposed by this for a while. I’d think about deleting some of the earliest repositories. Cleaning up the embarrassing parts. Curating my GitHub the way you’d curate a photo album before showing it to someone — removing the awkward shots, keeping only the flattering ones.</p><p>I almost did it more than once. Something kept stopping me, and it took a while to understand what that something actually was.</p><h3>What Stopped Me From Cleaning It Up</h3><p>The thing that stopped me, eventually, was a slow realization: the messy early commits weren’t actually evidence that I was bad at this. They were evidence that I’d been doing this for a while, consistently, and had clearly improved.</p><p>If I deleted the early stuff, what would be left was a profile that looked like I’d arrived already competent, which wasn’t true, and more importantly, wasn’t useful to anyone, including future me.</p><p>A curated, polished-from-day-one profile tells a much less interesting story than a messy, honest one. Anyone can present a handful of clean final projects. Far fewer people can show an actual, visible trajectory — here’s where I started, here’s what I didn’t understand yet, here’s how the code changed as I understood more.</p><p>That trajectory is the actual valuable thing. Not any single repository. The shape of the whole timeline.</p><blockquote><em>A polished portfolio shows what you can do today. A messy public history shows how fast you’re capable of changing. The second thing is rarer and more convincing.</em></blockquote><h3>What This Actually Looks Like on My Profile Now</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RASSATop0IMXVVXrwFJhQA.png" /><figcaption>GitHub repository list interface, multiple folders with green commit dots, code timeline visualization, dark theme, no faces</figcaption></figure><p>If you look at my GitHub now, you’d see exactly what I’m describing. Early repositories with code that’s functional but unrefined — Beecrowd solutions with minimal structure, simple variable names, the kind of code you write when you’re focused entirely on getting the logic right and haven’t yet developed habits around readability or style.</p><p>Then, moving forward chronologically, you’d see the same kind of problems being solved with more structure. Better naming. Comments that explain reasoning rather than just narrating what a line does. A growing awareness that code isn’t just for the computer to execute — it’s for a human, possibly a future version of myself, to read and understand later.</p><p>None of this was deliberate documentation. I never sat down and thought, “I should structure my commits to show growth.” It happened naturally, as a side effect of actually getting better and just continuing to push code publicly the whole time.</p><p>That’s the part that makes it feel authentic rather than performed. Nobody can fake a multi-month trajectory of gradual, consistent improvement. You either have one, or you don’t.</p><h3>Why This Matters More Than I Initially Realized</h3><p>I used to think the value of a public GitHub was mainly about having projects to show recruiters — a portfolio, essentially, in the same category as a resume or a LinkedIn profile.</p><p>I’ve come to think the value is actually different and bigger than that.</p><p><strong>It proves consistency in a way that’s hard to fake.</strong><br> Anyone can claim they’ve been learning to code for six months. A GitHub history with commits spread across that entire period, showing actual activity rather than a sudden burst right before a job application, is much harder evidence to dismiss.</p><p><strong>It shows how you think, not just what you produce.</strong><br> Reading someone’s commit history — the false starts, the refactors, the moments where you can see them realize a better approach mid-project — tells a more complete story than a single finished snapshot. It shows process, not just output.</p><p><strong>It removes the pressure to be perfect before sharing.</strong><br> Once you accept that your public profile will show imperfect work, you stop hesitating before pushing something just because it isn’t polished yet. This alone made me ship things faster and more often, because I’d already let go of the fear of being seen mid-progress.</p><p><strong>It builds an honest relationship with your own growth.</strong><br> Going back and looking at code you wrote six months ago and being able to clearly identify what you’d do differently now is one of the most concrete ways to actually feel your own progress. A curated, deleted-and-replaced history doesn’t give you that same evidence.</p><h3>The Recruiter Angle, Specifically</h3><p>I’ve heard enough from people further along in their careers to know this matters specifically for job searching, even though that wasn’t my original motivation for keeping things public.</p><p>A recruiter or hiring manager looking at a junior candidate’s GitHub isn’t expecting to see senior-level code. They’re expecting to see exactly what a learning developer’s code looks like — and what they’re actually evaluating is whether there’s a visible trajectory of improvement, whether the person ships consistently, and whether the commit messages and structure suggest someone who’s developing good habits over time.</p><p>A profile with three polished, possibly recently cleaned-up projects and nothing else tells a thin story. A profile with a long, visible, slightly messy history that clearly shows someone getting better month over month tells a much more convincing one — especially for a first- or second-year student who isn’t expected to already be excellent.</p><blockquote><em>Consistency is the actual signal recruiters are looking for in a junior candidate’s GitHub. Perfection isn’t, because nobody expects it yet.</em></blockquote><h3>What I’d Tell Someone Deciding Whether to Go Public</h3><p>If you’re a student right now deciding whether to make your repositories public or keep them private until they’re “ready,” here’s what I’d say based on going through this myself.</p><p>There is no point where your early work will feel ready. The standard you’re holding yourself to keeps moving as you improve, which means if you wait for your code to feel good enough to show, you’ll wait indefinitely.</p><p>The discomfort of having imperfect work visible fades faster than you expect, and it fades specifically because you keep producing more work that makes the earlier stuff look like a natural starting point rather than a permanent embarrassment.</p><p>Make it public from the start. Not because the code will look good — it won’t, not at first — but because the visible trajectory from not-good to better is the actual asset you’re building, and it only exists if the not-good part is still there to compare against.</p><h3>Where I Am Now</h3><p>My GitHub still has every awkward early commit sitting exactly where I left it. I haven’t deleted anything. I occasionally still cringe slightly looking back at some of it.</p><p>But I’ve stopped seeing that cringe as a problem to fix and started seeing it as proof that the version of me writing this article is meaningfully different from the version of me who pushed that first messy solution. That difference is the whole point.</p><p>If you’re earlier in this process than I am and your code right now feels too embarrassing to share publicly, I’d gently push back on that instinct. The embarrassment is temporary. The visible record of growth, once it exists, is permanent and genuinely valuable — to recruiters, sure, but honestly, mostly to you.</p><blockquote><em>Don’t wait until your code looks good to make it public. Make it public so you can watch it become good, in front of anyone who’s paying attention.</em></blockquote><p><em>Saharia Hassan Safin — CSE student at Daffodil International University, currently building in public and learning cybersecurity along the way. Find the messy, honest history on </em><a href="https://github.com/Safin313-REBORN"><em>GitHub</em></a><em> or connect on </em><a href="https://www.linkedin.com/in/saharia-hassan-safin/"><em>LinkedIn</em></a><em>. You can also check out my </em><a href="https://safin313-reborn.github.io/"><em>Portfolio</em></a><em>.</em></p><h3>Before you go</h3><ul><li>Please take a moment to like the post and follow the writer!</li><li>Did you know that over 400,000 developers share what they’re building, learning, and discovering across our platforms every month? Learn how you can contribute <a href="https://plainenglish.io/write-for-us">here</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7e00b75035e5" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/i-made-my-github-public-from-day-one-worst-decision-that-became-the-best-one-7e00b75035e5">I Made My GitHub Public From Day One — Worst Decision That Became the Best One</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My CSE Classes Teach Me to Pass Exams. My Self-Study Teaches Me How to Actually Build]]></title>
            <link>https://javascript.plainenglish.io/my-cse-classes-teach-me-to-pass-exams-my-self-study-teaches-me-how-actually-to-build-c518895676a9?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/c518895676a9</guid>
            <category><![CDATA[self-learning]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[students]]></category>
            <category><![CDATA[university-life]]></category>
            <category><![CDATA[ec]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Sun, 21 Jun 2026 17:51:00 GMT</pubDate>
            <atom:updated>2026-10-25T16:58:28.447Z</atom:updated>
            <content:encoded><![CDATA[<h4>The honest math of being a 1st-year student trying to learn two different curricula at once</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iO0rdTZGLbLdgC7zOHNoEw.png" /><figcaption>split image concept, university lecture hall on one side, home desk setup with terminal on the other side, dark contrast lighting, no faces, 16:9&quot;</figcaption></figure><blockquote><em>I’m enrolled at Daffodil International University as a CSE student. I attend classes, submit assignments, prepare for exams. And almost none of what I actually know about cybersecurity came from any of that. The honest truth is that I spend significantly more hours self-studying than I do on my actual coursework — and I think that gap says something important about computer science education that nobody likes to say out loud.</em></blockquote><h3>The Two Curricula I’m Actually Following</h3><p>There’s the curriculum DIU has designed for me — a structured, sequenced path through programming fundamentals, data structures, discrete mathematics, and eventually more specialized courses as I progress through the years.</p><p>And then there’s the curriculum I’ve built for myself outside of class — Cisco certifications, YouTube tutorials, TryHackMe rooms, CTF writeups, hours spent breaking Linux installations, evenings spent reading CVE reports.</p><p>These two curricula exist in parallel. They overlap occasionally. But the honest accounting of my time would show that the second one — the one nobody is grading, nobody assigned, nobody is checking whether I complete — takes up dramatically more of my actual learning hours than the first one does.</p><p>I don’t say this as a criticism of my university specifically. I think this is closer to the default state of computer science education everywhere, especially for anyone genuinely interested in a specialized, fast-moving field like cybersecurity.</p><h3>Why the Gap Exists</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y1_AAbK3zYoceoTT6tDapg.png" /><figcaption>University course syllabus document on screen next to cybersecurity learning roadmap, comparison concept, dark theme, no faces</figcaption></figure><p>University curricula move slowly, by design. Course content gets reviewed, approved, and scheduled months or years in advance. A four-year degree program is built around the assumption that foundational knowledge — algorithms, data structures, systems concepts — stays relevant regardless of which specific year you’re studying it.</p><p>That foundational approach makes sense for a lot of computer science. Discrete mathematics doesn’t change. The fundamentals of how a CPU executes instructions don’t change much year to year.</p><p>Cybersecurity moves differently. New vulnerabilities are discovered constantly. New attack techniques emerge faster than any curriculum committee could realistically incorporate them into an approved syllabus. The tools penetration testers use today are meaningfully different from the tools used five years ago. A security course designed and approved two years ago is already behind the current threat landscape by the time students are sitting in the classroom learning it.</p><p>This isn’t a failure of any specific university. It’s a structural mismatch between how academic curricula are built and how fast this particular field actually moves.</p><h3>What My Actual Week Looks Like</h3><p>I want to be concrete about this instead of just describing it abstractly.</p><p>A typical week involves attending scheduled classes, working through assignments related to whatever programming concepts or theory we’re covering that semester, and studying for upcoming exams or quizzes. This is real, structured, and it does teach me things — discrete math has genuinely improved my logical reasoning, and programming courses reinforced fundamentals I use constantly.</p><p>But the same week also involves multiple evenings spent on TryHackMe rooms that have nothing to do with anything covered in any of my courses. Hours reading write-ups about vulnerabilities that were disclosed last month, not five years ago. Time spent in a Linux terminal troubleshooting something that broke, building the kind of practical comfort with the operating system that no course I’m taking addresses directly.</p><p>If I had to guess at the actual time split, self-study would significantly outweigh formal coursework — not because I’m neglecting my classes, but because the things I actually want to be good at simply aren’t covered in them yet, or won’t be for a few more years as the curriculum eventually catches up.</p><h3>The Frustration of This, Honestly</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Hr641q7lPv47-bpnkrWp9Q.png" /><figcaption>Male student looking at clock and calendar overlaid with study materials, time management concept, warm desk lighting, no faces</figcaption></figure><p>There’s a specific frustration that comes from this gap, and I think it’s worth naming directly instead of glossing over it.</p><p>Sometimes I sit through a lecture covering something I find genuinely less urgent than what I was reading about the night before — some CVE writeup, some new technique I’d seen discussed in a security community — and I have to consciously remind myself that the lecture content matters too, even if it doesn’t feel as immediately exciting.</p><p>There’s also a time-management tax to running two curricula simultaneously. Every hour I spend on self-study is an hour I’m not spending on coursework, and vice versa. I haven’t found a perfect formula for balancing this. I’ve mostly found an uneasy equilibrium where neither side gets neglected entirely, but neither side gets as much attention as I’d ideally want to give it either.</p><p>And there’s a quieter frustration too — the sense that the most exciting, most current, most relevant things I’m learning are entirely self-directed, which means there’s no external structure pushing me to stay consistent. University deadlines exist whether I want them to or not. Self-study deadlines only exist if I create and enforce them myself, and that’s a much easier thing to let slide on a hard week.</p><h3>Why I Don’t Think the University Path Is Wasted Time</h3><p>Despite all of this, I don’t think the structured university path is wasted effort, and I want to push back on my own framing a little here.</p><p>The discrete mathematics I’m learning genuinely underlies a lot of the logical thinking I use when approaching security problems. The programming fundamentals — even the basic ones that feel slow compared to what I’m self-teaching — built the foundation that makes my self-study actually stick rather than feeling like memorized trivia.</p><p>There’s also something structurally valuable about being forced to learn things you wouldn’t have chosen to prioritize on your own. Self-study, left completely unstructured, tends to follow your existing interests and avoid your existing weaknesses. University coursework doesn’t care what you find interesting. It makes you sit with discrete math even when you’d rather be reading about buffer overflows, and that discipline has genuine value, even when it doesn’t feel exciting in the moment.</p><blockquote><em>University gives me the foundation I didn’t know I needed. Self-study gives me the specific skills I know I want. I need both, even though only one of them feels urgent most days.</em></blockquote><h3>How I’ve Started Managing the Balance</h3><p>I haven’t solved this perfectly. But here’s what’s actually working for me right now, in practice.</p><p><strong>I treat coursework as non-negotiable time, scheduled first.</strong><br> Class attendance, assignment deadlines, and exam preparation get fixed slots that I don’t compromise on, specifically because nothing about self-study has an external enforcement mechanism if I let coursework slide.</p><p><strong>I look for overlap deliberately.</strong><br> When a course touches on something tangentially related to security — networking concepts, basic discrete math used in cryptography, programming patterns that show up in vulnerability analysis — I try to go slightly deeper on that specific topic during self-study, so the two curricula reinforce each other instead of feeling completely separate.</p><p><strong>I protect specific self-study time the same way I protect class time.</strong><br> If self-study only happens in whatever time happens to be left over after everything else, it gets squeezed out completely during busy weeks. I’ve started blocking it the same way I’d block a class — not flexible, not optional, even if it’s just an hour.</p><p><strong>I stopped expecting the university to teach me everything I want to know.</strong><br> This sounds obvious written out, but it took me a while to actually internalize it emotionally rather than just intellectually. Once I stopped resenting my coursework for not covering the things I was excited about, the frustration mostly disappeared, and I could just appreciate it for what it actually does well.</p><h3>What I’d Tell Another First-Year Student</h3><p>If you’re in a similar position — studying CSE formally while genuinely caring about a fast-moving specialization like cybersecurity, AI, or anything else that moves faster than curriculum committees can track — here’s what I’d say.</p><p>The gap between what your university teaches and what you actually want to know is not a sign that your university is bad or that you’re wasting your time there. It’s closer to a structural feature of how formal education works for any field that changes quickly. Expecting otherwise will just leave you perpetually frustrated with an institution that was never designed to move at the speed you want it to.</p><p>Your self-study is not a replacement for your degree. It’s a parallel track that makes the degree more valuable, because you’re graduating with both the foundational credibility a degree provides and the current, practical skills that most of your peers who only did the assigned coursework won’t have.</p><p>Don’t let the self-study become an excuse to neglect coursework, and don’t let coursework convince you that you don’t need the self-study. Both tracks are doing different jobs. Trying to make one fully replace the other is where the real problems start.</p><h3>Where I Am Now</h3><p>I’m still in my first year. I still sit through lectures sometimes wishing I could be reading the latest security write-up instead. I still stay up later than I should some nights, working through a TryHackMe room that has nothing to do with anything due tomorrow.</p><p>But I’ve stopped seeing this as a conflict I need to resolve and started seeing it as the actual, accurate shape of learning a fast-moving field while also completing a traditional degree. The two curricula aren’t going to merge into one smooth, unified experience. They’re going to keep running in parallel, occasionally overlapping, mostly separate, both genuinely necessary.</p><p>That’s not a problem to fix. That’s just what it actually looks like to take both your formal education and your real interests seriously at the same time.</p><blockquote><em>My degree will tell employers I finished something structured and difficult. My self-study will show them what I actually care about and how far I’ll go to learn it on my own. I need both stories to be true.</em></blockquote><p><em>Saharia Hassan Safin — CSE student at Daffodil International University, balancing formal coursework with self-directed cybersecurity learning. Find projects on </em><a href="https://github.com/Safin313-REBORN"><strong><em>GitHub</em></strong></a><em> or connect on </em><a href="https://www.linkedin.com/in/saharia-hassan-safin/"><strong><em>LinkedIn</em></strong></a><em>. You can also check out my </em><a href="https://safin313-reborn.github.io/"><strong><em>Portfolio</em></strong></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c518895676a9" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/my-cse-classes-teach-me-to-pass-exams-my-self-study-teaches-me-how-actually-to-build-c518895676a9">My CSE Classes Teach Me to Pass Exams. My Self-Study Teaches Me How to Actually Build</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Is Changing Cybersecurity — Here’s What a Student Like Me Needs to Know]]></title>
            <link>https://medium.com/ai-security-hub/ai-is-changing-cybersecurity-heres-what-a-student-like-me-needs-to-know-84a699d28d7a?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/84a699d28d7a</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[students]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Sat, 20 Jun 2026 11:56:00 GMT</pubDate>
            <atom:updated>2026-10-25T16:58:51.086Z</atom:updated>
            <content:encoded><![CDATA[<h4>I learned half of what I know about security by arguing with a chatbot at 2 am.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HASQntkC0LGgkDvH6Z6xqA.png" /><figcaption><em>Glowing neural network pattern merging into a padlock shape, dark blue and green gradient background, futuristic minimal, no text, 16:9</em></figcaption></figure><blockquote><em>I learned more about buffer overflows from a back-and-forth conversation with an AI chatbot at 2am than I did from three YouTube tutorials combined. Not because the AI is smarter than the people who made those tutorials. Because I could ask it the dumb follow-up question I was too embarrassed to ask anyone else.</em></blockquote><h3>The Honest Starting Point</h3><p>Before I get into anything about how AI is reshaping the security industry — the threat detection systems, the automated red teaming, the AI-powered malware — I want to start with the much smaller, much more personal way AI has actually shown up in my learning so far.</p><p>I use ChatGPT and Claude constantly while studying cybersecurity. Not to write my work for me. To explain things to me, at whatever level of detail I need, exactly when I need it, without judgment for not already knowing.</p><p>That’s the real story for a student like me. The industry-level AI transformation is happening too, and it matters — but it’s the personal tutor use case that has actually changed how I learn day to day.</p><h3>How I Actually Use AI to Learn Security</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E6p9N1RbNQCgneIYogZ74g.png" /><figcaption>Split-screen laptop showing chat conversation on one side, terminal code on the other, dark room, soft glow, no faces</figcaption></figure><p>Here’s a real pattern from my own studying.</p><p>I’ll be watching a YouTube tutorial on, say, SQL injection. The instructor moves fast, assuming I already know what a parameterized query is. I don’t. In the old version of me, I would have either paused, gotten frustrated, and given up for the day, or kept watching while understanding less and less.</p><p>Now I open a chat with Claude or ChatGPT and just ask: “What is a parameterized query and why does it prevent SQL injection? Explain as I’ve never seen one before.”</p><p>I get an explanation built specifically for where I am, not where the average viewer of that tutorial is assumed to be. I can ask the follow-up question that would feel embarrassing to ask a human instructor in front of other people. I can ask it three different ways until one explanation actually clicks.</p><p>Then I go back to the tutorial, and suddenly the next twenty minutes make sense.</p><p>This loop — get stuck, ask AI for the missing piece, return to the real resource — has probably saved me dozens of hours of confusion over the past several months.</p><h3>The Specific Ways This Has Helped Me</h3><p><strong>Breaking down jargon in real time.</strong><br> Security content is full of acronyms and terminology that assume prior knowledge — CSRF, IDOR, SSRF, privilege escalation, and lateral movement. I used to keep a separate tab open just for Googling terms mid-video. Now I paste the term into a chat and get a clear explanation immediately, often with an analogy that actually makes it stick.</p><p><strong>Explaining code I don’t fully understand.</strong><br> When I’m reading a CVE writeup or a proof-of-concept exploit script, there’s often code involved that I can follow line by line but don’t fully understand at a conceptual level. I’ll paste a snippet and ask what it’s actually doing and why it works. This has taught me more about C and Python internals than most tutorials, because the explanation is tailored exactly to the code in front of me.</p><p><strong>Rubber duck debugging with actual answers.</strong><br> When I’m trying to set up a tool — configuring Burp Suite, getting a TryHackMe VPN connection working, fixing a broken Linux package dependency — I used to spend hours searching forums for someone with my exact error message. Now I describe the problem and often get pointed in the right direction immediately, or at least get a clearer sense of what to search for next.</p><p><strong>Generating practice scenarios.</strong><br> I’ve asked AI to create simple, deliberately vulnerable code examples so I can practice spotting the vulnerability myself before checking if I got it right. It’s like having a study partner who can generate unlimited practice problems on demand.</p><h3>What AI Cannot Do — And Why That Matters More</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wP7BBV2dQXerESGr-4jaGA.png" /><figcaption>Person looking at terminal screen with confused expression replaced by code only, dark room, contemplative mood, no faces</figcaption></figure><p>I want to be clear about the limits of this, because I think overselling AI as a learning tool would be dishonest and also dangerous in a field like security.</p><p><strong>AI gets things wrong, confidently.</strong><br> I’ve had explanations that sounded completely correct and were subtly wrong in ways I only caught later by cross-referencing real documentation or asking someone who actually knew the material. In security, a subtly wrong understanding of how a vulnerability works can be worse than no understanding at all, because it gives you false confidence.</p><p><strong>AI cannot give you hands-on experience.</strong><br> Understanding how SQL injection works conceptually is different from successfully finding and exploiting one in a real, messy, unpredictable target on TryHackMe or HackTheBox. AI can explain the theory beautifully. It cannot do the actual hacking for you, and trying to make it do so defeats the entire point of learning.</p><p><strong>AI cannot replace the community.</strong><br> The writeups, the live hacking streams, the Discord servers full of people sharing what they’re learning — none of that is replaceable by a chatbot. AI is a tool I use alongside the community, not instead of it.</p><p><strong>Over-reliance creates a different kind of weak foundation.</strong><br> If every time I get stuck, I immediately ask AI instead of struggling with the problem for a while first, I lose the actual skill of problem-solving under confusion, which is most of what real security work actually is. I’ve had to be deliberate about letting myself stay stuck for a bit before reaching for help.</p><h3>The Bigger Picture — How AI Is Reshaping Cybersecurity as a Field</h3><p>Beyond my own personal study habits, AI is changing the actual practice of cybersecurity in ways that matter for anyone planning a career in this space.</p><p><strong>Defensive side: AI-powered threat detection.</strong><br> Modern security operations centers increasingly use machine learning models to detect anomalous behavior across networks — patterns that would be impossible for a human analyst to spot manually across millions of log entries. Understanding how these systems work and their limitations is becoming part of the baseline knowledge for SOC analyst roles.</p><p><strong>Offensive side: AI-assisted red teaming.</strong><br> Penetration testers are starting to use AI tools to help generate attack scenarios, analyze code for potential vulnerabilities faster, and automate parts of reconnaissance that used to take hours of manual work. This doesn’t replace the tester — it changes what they spend their time on.</p><p><strong>The attacker side too.</strong><br> This goes both ways. Attackers are using AI to write more convincing phishing emails, to generate polymorphic malware that changes its signature to evade detection, and to automate vulnerability discovery at scale. Security professionals now need to understand AI not just as a tool they use, but as a tool that’s actively used against the systems they defend.</p><p><strong>New job categories are emerging.</strong><br> AI security — the practice of securing AI systems themselves, and the practice of using AI for security — is becoming its own specialization. Prompt injection attacks against AI systems, data poisoning of training sets, adversarial inputs designed to fool machine learning models — these are real, current concerns that didn’t exist as job categories five years ago.</p><h3>What This Means for Someone Like Me</h3><p>I’m a first-year CSE student. I’m not in a position to predict exactly how AI will reshape the cybersecurity job market by the time I graduate. Nobody really can, with full confidence — the field is moving too fast.</p><p>But here’s what I’m doing about it, practically:</p><p>I’m using AI as a learning accelerator, not a shortcut. Every time I use it to understand a concept, I try to verify that understanding against a real source — documentation, a write-up, a course — before I consider it solid.</p><p>I’m paying attention to how AI is being used in the tools I’m already learning. Burp Suite has AI-assisted features now. Understanding how they work and where they fail feels like a more durable skill than memorizing today’s specific tool interface.</p><p>I’m trying to understand AI security as its own emerging subfield, not just as a tool I use for studying. Prompt injection, AI model security, adversarial machine learning — these terms are starting to show up in job postings, and I’d rather be early to understanding them than catching up later.</p><blockquote><em>The students who will do well in this field aren’t the ones who avoid AI or the ones who lean on it for everything. They’re the ones who use it deliberately, know exactly what it’s good for, and never stop verifying what it tells them.</em></blockquote><h3>A Real Example From Last Week</h3><p>To make this concrete: last week, I was reading about a privilege escalation technique I didn’t fully understand. I asked Claude to explain it, got a clear breakdown of the mechanism, then went and found the actual technical write-up it was based on to verify the explanation held up. It did, mostly — with one detail that the AI had oversimplified in a way that mattered.</p><p>That oversimplification was actually useful. It taught me something about being precise with security concepts that a perfect explanation wouldn’t have. Catching the gap between the simplified version and the real version was, itself, part of the learning.</p><p>This is what I mean by using AI deliberately. Not blind trust. Not avoidance. A tool that speeds up the first ninety percent of understanding, paired with the discipline to verify the last ten percent that actually matters.</p><h3>Where I Land On This</h3><p>AI hasn’t made cybersecurity easier to learn in some shortcut sense. It’s made it more accessible to learn at my own pace, in my own gaps of understanding, without needing a mentor sitting next to me at 2 am.</p><p>The field itself is changing because of AI — on both the defensive and offensive sides, in ways that will define a meaningful part of the job market I’m hoping to enter in a few years. I don’t think that’s something to be afraid of. I think it’s something to pay attention to early, the same way I paid attention to Linux and C early, because the people who understand the new tools first tend to be the people who get hired first.</p><p>For now, my approach is simple: use AI to learn faster, verify everything that matters, and stay close enough to the actual community and actual practice that I never mistake a good explanation for real experience.</p><blockquote><em>The chatbot taught me the words. The terminal taught me the truth. I need both.</em></blockquote><p><em>Saharia Hassan Safin — CSE student at Daffodil International University, currently obsessed with cybersecurity, AI, and building (and breaking) things. Find projects on </em><a href="https://github.com/Safin313-REBORN"><em>GitHub</em></a><em> or connect on </em><a href="https://www.linkedin.com/in/saharia-hassan-safin/"><em>LinkedIn</em></a><em>. You can also check out my </em><a href="https://safin313-reborn.github.io/"><em>Portfolio</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84a699d28d7a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ai-security-hub/ai-is-changing-cybersecurity-heres-what-a-student-like-me-needs-to-know-84a699d28d7a">AI Is Changing Cybersecurity — Here’s What a Student Like Me Needs to Know</a> was originally published in <a href="https://medium.com/ai-security-hub">AISecHub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Tried Almost Every Linux Distro in 6 Months — Here’s the One That Finally Stuck]]></title>
            <link>https://medium.com/codex/i-tried-almost-every-linux-distro-in-6-months-heres-the-one-that-finally-stuck-96df32f40cc7?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/96df32f40cc7</guid>
            <category><![CDATA[arch]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[debian]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Fri, 19 Jun 2026 11:31:00 GMT</pubDate>
            <atom:updated>2026-11-04T15:49:35.583Z</atom:updated>
            <content:encoded><![CDATA[<h4>Kali, Ubuntu, Parrot, Fedora, Arch, Manjaro — and the surprising winner</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JQpDudau5dXtkJwEbAYZfQ.png" /><figcaption>Multiple Linux terminal windows with different color schemes, dark desk setup, glowing screens, cinematic, no text, 16:9</figcaption></figure><blockquote><em>Six months ago I had one operating system installed on my laptop, ever, in my entire life: Windows. Today I can tell you, from broken bootloaders and burnt weekends, exactly why Debian-based distros are where I landed — and exactly why Arch nearly broke my spirit trying to get there.</em></blockquote><h3>How This Started</h3><p>I wrote before about installing Kali Linux for the first time and immediately breaking my boot. That wasn’t a one-time event. That was the opening scene of a six-month saga.</p><p>Once I got Kali working, I didn’t stop. Something about having broken something and fixed it made me want to break more things. Each distro felt like a different personality — different defaults, different philosophies, different ways of making the same Linux kernel feel completely different to use.</p><p>So I went through almost all of them. Not as a structured plan. As curiosity kept escalating.</p><h3>Round 1: Kali Linux — The Gateway Drug</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lO1mufI0-rsSa6f6aKoybA.png" /><figcaption>Kali Linux desktop dark theme, terminal open, dragon logo visible, dramatic lighting, no faces</figcaption></figure><p>Kali was my first distro, and it’s built specifically for penetration testing and security work. Hundreds of tools preinstalled — Nmap, Wireshark, Metasploit, Burp Suite, all sitting there ready to use.</p><p>For a beginner, this is both a gift and a trap. The gift: everything you need is already there. The trap: you have no idea what 90% of those tools do, and the interface assumes you already know.</p><p>I broke my boot loader on day one. Spent an entire afternoon recovering it through trial, error, and half-understood Stack Overflow answers. By the time I had it stable, I’d learned more about GRUB than I ever wanted to.</p><p>Kali taught me the basics — terminal navigation, package managementapt, and file permissions. It&#39;s Debian-based under the hood, which I haven&#39;t fully appreciated the significance of yet.</p><p><strong>Verdict:</strong> Great for security tools. Rough for an absolute beginner’s first distro. I’d recommend it as your second or third distro, not your first.</p><h3>Round 2: Ubuntu — The Comfortable Middle Ground</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TRGM9Nt4Y8mOzcJjH2VpPg.png" /><figcaption>Ubuntu desktop orange and purple theme, clean modern interface, laptop on desk, soft lighting, no faces</figcaption></figure><p>After surviving Kali, I tried Ubuntu — probably the most beginner-friendly distro that exists. Things just worked. Drivers are installed automatically. The software center had everything I needed. The community support online is enormous; any problem I had, someone else had already solved and documented.</p><p>Ubuntu is also Debian-based, and this is where I started noticing a pattern: the distros that felt stable and predictable kept tracing back to the same root.</p><p>The downside of Ubuntu, for someone trying to learn deeply, is that it hides a lot of complexity. It’s designed to just work, which is great for daily use but means you don’t get forced into understanding what’s happening underneath as much.</p><p><strong>Verdict:</strong> Excellent daily driver. Too smooth if you’re trying to learn the hard way.</p><h3>Round 3: Parrot OS — Kali’s Quieter Cousin</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TnsaR_daGAuUM05aImI7sA.png" /><figcaption><em>Parrot OS desktop teal theme, terminal with security tools, dark modern interface, no faces</em></figcaption></figure><p>Parrot OS is another security-focused distro, also Debian-based, often compared directly to Kali. It felt lighter, a bit more polished in places, with a slightly different tool selection and a forensics mode I found genuinely interesting.</p><p>By this point, switching between Debian-based distros felt natural. The package manager was the same. File structures were familiar. Configuration patterns I’d learned on Kali transferred directly. This was the first time I noticed that the underlying base mattered more than the branding on top.</p><p><strong>Verdict:</strong> Solid alternative to Kali. Didn’t feel dramatically different, but confirmed the Debian Foundation was something I was comfortable with.</p><h3>Round 4: Fedora — The Different Philosophy</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FLATbTHMVpgcoIFtNvJHZg.png" /><figcaption>Fedora Linux desktop blue theme, GNOME interface, modern minimal desktop, soft light, no faces</figcaption></figure><p>Fedora was my first real departure from the Debian family. It uses dnf instead of aptRPM packages instead of DEB, and a different release philosophy focused on shipping newer software faster.</p><p>The differences were small individually, but added up. Commands I’d memorized didn’t work. Configuration file locations were sometimes different. Nothing was broken — it was just a different dialect of the same language, and I had to relearn vocabulary I thought I already knew.</p><p>Fedora is genuinely well-engineered. Red Hat backs it, and it’s often used as a testing ground for features that eventually land in RHEL. But the friction of relearning package management slowed me down more than I expected.</p><p><strong>Verdict:</strong> Technically excellent. Personally, the dialect switch cost me more time than the benefits were worth at my skill level.</p><h3>Round 5: Arch Linux — Where My Confidence Died</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HD7ETzS4FG5sFhishZvvVA.png" /><figcaption><em>Arch Linux terminal installation screen, command line text only, dark background, minimal aesthetic, no faces</em></figcaption></figure><p>Then I tried Arch.</p><p>If you don’t know Arch’s reputation, it doesn’t have a graphical installer by default. You partition your own disk manually. You mount your own filesystems manually. You install the base system, configure the bootloader, set up networking, and build your desktop environment piece by piece — all from the command line, all by following documentation that assumes you already understand most of what it’s explaining.</p><p>The Arch Wiki is famous for being one of the best pieces of Linux documentation that exists. It’s also famous for assuming a baseline of knowledge that I simply didn’t have yet.</p><p>I followed the installation guide carefully. I made it through partitioning. I made it through the base install. I got stuck on bootloader configuration in a way I couldn’t recover from, and after several hours of trying, I had to start over completely.</p><p>I tried Arch two more times over the following weeks. Each time I learned more and got slightly further. Each time something else broke that I didn’t have the knowledge to fix.</p><p>Arch wasn’t impossible. People far less experienced than career sysadmins install it successfully all the time. But for me, at that point in my learning, it was a wall I kept running into rather than a hill I was climbing.</p><p><strong>Verdict:</strong> Incredible learning tool if you have the patience and time to dedicate to it properly. Genuinely humbling. I respect it more than I enjoyed it.</p><h3>Round 6: Manjaro — Arch Without the Pain (Mostly)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XJyIELe2y5156l2oR5BWuA.png" /><figcaption>Manjaro Linux desktop green theme, modern desktop environment, clean interface, no faces</figcaption></figure><p>After Arch defeated me three times, I tried Manjaro — an Arch-based distro that includes a graphical installer and handles a lot of the manual setup automatically while still giving you access to the Arch User Repository and rolling release model.</p><p>This felt like cheating in a good way. I got the benefits people talk about with Arch — access to almost any package imaginable, a more cutting-edge software experience — without the multi-hour manual partition-and-configure process that had broken me three separate times.</p><p>It worked well for a while. Then a system update broke my graphics drivers in a way that took a full evening to diagnose and fix. This is a known characteristic of rolling release distros — newer software means occasionally unstable software, and Arch-based systems in particular are known for this trade-off.</p><p><strong>Verdict:</strong> A genuinely good middle ground if you want Arch’s ecosystem without Arch’s installation process. But the rolling release instability reminded me why I value boring, predictable systems for daily use.</p><h3>What I Actually Learned From All of This</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JEBCxMUtQ8BPjlilQoXfRg.png" /><figcaption>Comparison chart concept, two paths diverging, one smooth, one rocky, minimal flat illustration, dark background</figcaption></figure><p>After going through this many distros, a pattern became impossible to ignore.</p><p>Every distro I genuinely enjoyed using day to day was Debian-based. Kali, Ubuntu, Parrot — different purposes, different interfaces, but the same underlying package management, the same stability philosophy, the same predictable behavior when things went wrong.</p><p>Every distro that fought me the hardest was Arch-based. Arch itself, and even Manjaro, despite its easier installation, both carried the rolling-release trade-off of bleeding-edge software occasionally breaking things in ways that took real time to fix.</p><p>This isn’t a universal truth about which family is “better” — plenty of experienced Linux users run Arch as their daily driver without issues, because they have the troubleshooting skills to fix problems quickly when they arise. The lesson is more personal: at my current skill level, Debian’s conservative, well-tested approach to package stability matched how much time I actually had to spend debugging a broken system versus learning new things.</p><blockquote><em>Arch teaches you the most. Debian lets you actually get work done while you’re still learning everything else.</em></blockquote><h3>Why Debian Specifically Won For Me</h3><p>By the end of these six months, I stopped distro-hopping and settled on a Debian-based setup as my daily driver. Here’s specifically why:</p><p><strong>Stability over bleeding edge.</strong><br>Debian’s release philosophy prioritizes tested, stable packages over having the newest version of everything. For someone still learning, a system that doesn’t randomly break after an update is worth more than having the latest software version a few weeks earlier.</p><p><strong>The package ecosystem is enormous.</strong><br>apt has access to a massive software repository, and because Ubuntu, Kali, and Parrot are all Debian-based, almost every tutorial, every Stack Overflow answer, every guide I&#39;d already half-memorized still applied directly.</p><p><strong>The learning curve was sustainable.</strong><br>I could learn new things — new tools, new configurations, new security concepts — without simultaneously fighting my own operating system. Arch demanded I solve operating system problems before I could even get to the things I actually wanted to learn.</p><p><strong>The documentation and community match my level.</strong><br>Debian and Ubuntu have enormous, beginner-friendly communities. When something breaks, the fix is usually a quick search away, written by someone who assumes the reader is still learning.</p><h3>What I’d Tell Someone Starting Today</h3><p>If you’re a beginner trying to figure out which distro to start with, here’s my honest advice based on six months of breaking things:</p><p>Start with Ubuntu if you want to learn Linux concepts without fighting your operating system constantly. It’s Debian-based, has the most beginner resources online, and just works.</p><p>Move to Kali or Parrot once you’re comfortable with the terminal and want security-specific tools. Both are Debian-based, so the transition is smooth.</p><p>Try Arch eventually — not as your daily driver yet, but as a deliberate learning exercise on a spare partition or virtual machine where breaking it doesn’t cost you anything important. The Arch Wiki alone is worth the experience, even if you end up going back to something more stable afterward.</p><p>Skip the temptation to jump straight to the “advanced” distros because they sound impressive. I wasted real time trying to run before I could walk, and the broken systems didn’t make me look advanced — they just slowed down my actual learning.</p><blockquote><em>The “best” distro isn’t the one with the best reputation. It’s the one that lets you spend your time learning what you actually wanted to learn instead of fixing your own operating system.</em></blockquote><h3>Where I Am Now</h3><p>I run a Debian-based system as my daily driver. I still keep Arch on a separate partition because I’m not done with it — I want to go back and actually finish that installation properly, on my own terms, when I have the patience for it.</p><p>But for the work I’m actually trying to do — learning cybersecurity, building projects, practicing on TryHackMe, writing code — Debian gets out of my way and lets me focus on the things I came to learn in the first place.</p><p>Six months ago,o I didn’t know what a bootloader was. Now I’ve broken several of them, fixed most of them, and have a genuine opinion about which Linux family fits how I learn. That opinion came from time spent failing, not from reading a single “best distro for beginners” listicle.</p><blockquote><em>Try the distros. Break them. Find the one that gets out of your way. That’s the only research method that actually works.</em></blockquote><p><em>Saharia Hassan Safin — CSE student at Daffodil International University, currently obsessed with cybersecurity, Linux, and building (and breaking) things. Find projects on </em><a href="https://github.com/Safin313-REBORN"><em>GitHub</em></a><em> or connect on </em><a href="https://www.linkedin.com/in/saharia-hassan-safin//"><em>LinkedIn</em></a><em>. You can also check out my </em><a href="https://safin313-reborn.github.io/"><em>Portfolio</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=96df32f40cc7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/i-tried-almost-every-linux-distro-in-6-months-heres-the-one-that-finally-stuck-96df32f40cc7">I Tried Almost Every Linux Distro in 6 Months — Here’s the One That Finally Stuck</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Spent Months Grinding Beecrowd Problems — Here’s What Actually Changed in My Brain]]></title>
            <link>https://medium.com/codex/i-spent-months-grinding-beecrowd-problems-heres-what-actually-changed-in-my-brain-8b868229ed86?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/8b868229ed86</guid>
            <category><![CDATA[100daysofcode]]></category>
            <category><![CDATA[problem-solving]]></category>
            <category><![CDATA[competitive-programming]]></category>
            <category><![CDATA[beecrowd]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Thu, 18 Jun 2026 11:10:11 GMT</pubDate>
            <atom:updated>2026-11-06T09:57:45.367Z</atom:updated>
            <content:encoded><![CDATA[<h4>It wasn’t the problems. It was how my brain started seeing them.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-6K_qm-5GZ3NGY7oBJ9msQ.png" /><figcaption>Competitive programming judge interface on laptop screen, code editor with green accepted checkmarks, dark room, focused study atmosphere, no faces, 16:9</figcaption></figure><blockquote><em>I don’t actually know how many Beecrowd problems I’ve solved at this point. I stopped counting a while ago. What I do know is that the version of me who started was a completely different programmer than the version of me writing this. Not because I memorized more syntax. Because something fundamental shifted in how I look at a problem before I write a single line of code.</em></blockquote><h3>Why I Started</h3><p>I didn’t begin competitive programming because I had some grand plan about job interviews or building algorithmic intuition. I started because someone mentioned Beecrowd as a way to actually get good at programming instead of just following tutorials, and I was bored with following tutorials.</p><p>There’s a specific kind of frustration that comes from watching a coding tutorial, understanding every line as it’s explained, and then sitting down to write something yourself and realizing you don’t actually know how to start. I had that frustration a lot. I could read code. I struggled to produce it from a blank problem statement.</p><p>Beecrowd seemed like a direct fix for that. No tutorial holding your hand. Just a problem, a judge, and you.</p><h3>The Brutal First Stretch</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wlbmx_rCbGEMxlJYXjkTuw.png" /><figcaption>Frustrated coding session, error messages on terminal screen, dark room late at night, desk lamp glow, no faces</figcaption></figure><p>I want to be honest about how the beginning felt, because I think the sanitized version of these stories — where someone makes it sound like they just sat down and started crushing problems — does a disservice to anyone reading this who is currently stuck.</p><p>The first stretch was rough. Not dramatically, cinematically rough. Just consistently, quietly frustrating in a way that made me question whether I was actually built for this kind of thinking.</p><p>I’d read a problem statement and have no idea where to even begin. I’d see problems that seemed simple on the surface and submit a solution, only to get “wrong answer” with zero explanation of what input broke my logic. I’d stare at my own code, convinced it was correct, unable to see the edge case I’d missed.</p><p>There’s a specific kind of self-doubt that creeps in during this phase. You start wondering if everyone else just naturally sees these patterns, and you’re missing some fundamental piece of programmer intuition that you’ll never catch up on.</p><p>I didn’t have a breakthrough moment in this period. It was just slow, unglamorous repetition. Read the problem. Get stuck. Try something. Fail. Try something else. Sometimes succeed. Move to the next one.</p><h3>The Shift — When Logic Started Clicking</h3><p>Somewhere in the middle of this grind — I genuinely can’t point to the exact problem or the exact day — something started to change. It wasn’t sudden. It was gradual enough that I only noticed it in hindsight, the way you notice you’ve gotten stronger at the gym only when you pick up a weight that used to be hard and realize it isn’t anymore.</p><p>Problems that would have stumped me completely a few months earlier started to feel approachable. Not because I’d memorized the specific problem type. Because I’d started recognizing the shape of problems — the underlying pattern beneath the specific story the problem statement was wrapped in.</p><p>A problem about distributing candies among children and a problem about allocating resources across servers started looking like the same problem to me, even though the surface details were completely different. That’s the moment competitive programming actually starts paying off — when you stop seeing individual problems and start seeing categories of problems.</p><blockquote><em>The problems didn’t get easier. I got better at seeing what they actually were underneath the story.</em></blockquote><h3>What Actually Changed in How I Think</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*11qJB0w_jzgTZiE4Purgog.png" /><figcaption>Brain made of interconnected glowing nodes and pathways, abstract digital art style, blue and green colors, no text, no faces</figcaption></figure><p>Here’s what I can point to specifically, looking back at the difference between who I was and who I am now.</p><p><strong>I stopped writing code immediately.</strong><br> Early on, my instinct was to start typing as soon as I read a problem, figuring out the logic as I went. Now I spend real time just thinking before I write anything — breaking the problem into smaller pieces, identifying what data structure naturally fits, sketching the approach mentally or on paper before touching the keyboard. This single change probably did more for my problem-solving than any specific algorithm I learned.</p><p><strong>I learned to distrust my own confidence.</strong><br> I used to submit solutions the moment they compiled and seemed to produce the right output for the example case. Now I deliberately try to break my own logic before submitting — what’s the smallest possible input, the largest possible input, the weird edge case that doesn’t fit the pattern I designed for? This habit has saved me more wrong submissions than any specific technique.</p><p><strong>I started recognizing patterns across completely different problems.</strong><br> Two-pointer techniques, sliding windows, basic dynamic programming setups, graph traversal patterns — once you’ve seen them enough times in different disguises, you start recognizing the skeleton underneath new problems almost immediately. This is the actual point of grinding volume. It’s not about memorizing 100 specific solutions. It’s about building a mental library of shapes that problems tend to take.</p><p><strong>My relationship with being stuck changed completely.</strong><br> Being stuck used to feel like failure. Now it feels like the actual work. I expect to be stuck on most problems for at least a little while. The discomfort of not immediately knowing the answer stopped being something I tried to escape and became something I recognized as just part of the process.</p><p><strong>I got faster at reading, not just solving.</strong><br> A huge, underrated part of competitive programming is reading comprehension. Problem statements often bury the actual constraint that matters in a sentence that looks unimportant. I got noticeably better at reading a problem once and extracting the actual mathematical or logical question being asked, instead of needing to reread it five times.</p><h3>How This Connects to Everything Else I’ve Been Learning</h3><p>I didn’t start Beecrowd thinking about cybersecurity. But looking back, the way of thinking it built has shown up everywhere else in my learning since.</p><p>When I write C and have to think carefully about memory and pointer arithmetic, the same patient, structured thinking I built solving algorithm problems is what lets me actually follow what’s happening instead of just copying syntax I don’t understand.</p><p>When I read a CVE report describing a vulnerability, the pattern-recognition instinct I built from seeing hundreds of disguised versions of the same underlying problem on Beecrowd is the same instinct that helps me see the underlying mechanism of an exploit instead of getting lost in the specific details of that one case.</p><p>When I’m debugging a broken script and trying to figure out exactly which input is causing it to fail, the habit of trying to break my own logic before trusting it — built entirely from getting burned by edge cases on the judge — is directly useful.</p><p>Competitive programming didn’t teach me cybersecurity. It taught me a way of thinking that turned out to transfer into cybersecurity, into systems programming, into basically anything that requires patient, structured problem-solving under uncertainty.</p><h3>What I’d Tell Someone Just Starting</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cfNurAr0nXasv86HeFaNTg.png" /><figcaption><em>Person at desk with notebook and laptop, coding, warm lighting, motivational study atmosphere, no faces</em></figcaption></figure><p>If you’re a CS student staring at your first few Beecrowd problems, feeling exactly the frustration I described earlier, here’s what I wish someone had told me directly instead of letting me figure it out slowly.</p><p>The frustration at the beginning is not a sign that you’re bad at this. It’s the actual texture of learning to think this way. Everyone good at competitive programming went through this exact phase. The ones who got good are just the ones who kept showing up through it.</p><p>Don’t measure progress by how many problems you’ve solved. Measure it by whether problems that used to feel impossible start feeling merely hard, and problems that used to feel hard start feeling approachable. That shift is the real metric, and it doesn’t show up cleanly in a problem count.</p><p>Spend more time thinking before coding. This was the single highest-leverage change I made, and it’s available to anyone immediately — you don’t need to learn a new algorithm to start doing it.</p><p>Get comfortable being stuck. The discomfort doesn’t go away completely even when you get better. You just get better at sitting in it productively instead of panicking or giving up.</p><blockquote><em>Solving 100 problems doesn’t make you good at competitive programming. Noticing what changed in how you approach problem 100 compared to problem 1 — that’s the actual skill you were building the whole time.</em></blockquote><h3>Where I Am Now</h3><p>I’m still grinding. I haven’t reached some final destination where problems stop being hard — I don’t think that destination exists. I just keep encountering harder categories of problems that humble me the same way the easy ones did at the very beginning, and I keep working through that same uncomfortable, gradual process of getting better at seeing their shape.</p><p>What’s different now is that I trust the process. I know that the frustration I feel staring at a problem I can’t immediately solve isn’t a sign I’m failing. It’s a sign I’m exactly where the actual learning happens.</p><p>That trust — knowing that confusion is temporary and productive rather than permanent and disqualifying — might be the single most valuable thing competitive programming gave me. More valuable than any specific algorithm, more valuable than any specific technique. Just the calm certainty that being stuck is where the work gets done, and that I’ll get through it like I have every time before.</p><p><em>Saharia Hassan Safin — CSE student at Daffodil International University, currently grinding competitive programming and cybersecurity in parallel. Find projects on </em><a href="https://github.com/Safin313-REBORN"><em>GitHub</em></a><em> or connect on </em><a href="https://www.linkedin.com/in/saharia-hassan-safin/"><em>LinkedIn</em></a><em>. You can also check out my </em><a href="https://safin313-reborn.github.io/"><em>Portfolio</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8b868229ed86" width="1" height="1" alt=""><hr><p><a href="https://medium.com/codex/i-spent-months-grinding-beecrowd-problems-heres-what-actually-changed-in-my-brain-8b868229ed86">I Spent Months Grinding Beecrowd Problems — Here’s What Actually Changed in My Brain</a> was originally published in <a href="https://medium.com/codex">CodeX</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Every Developer Should Learn Cybersecurity Before Writing Their First Line of Code]]></title>
            <link>https://medium.com/ai-security-hub/why-every-developer-should-learn-cybersecurity-before-writing-their-first-line-of-code-43e176ad57fd?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/43e176ad57fd</guid>
            <category><![CDATA[security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[devsecops]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Thu, 18 Jun 2026 10:08:11 GMT</pubDate>
            <atom:updated>2026-10-25T17:00:02.633Z</atom:updated>
            <content:encoded><![CDATA[<h4>Security isn’t a feature you add later. It’s a mindset you build from day one.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0huTnh7JN-GqJQ2NWaYVZg.png" /><figcaption>Developer writing code on dark screen, subtle glowing padlock overlay, cinematic blue and green lighting, no text, 16:9</figcaption></figure><blockquote>I want to tell you something that nobody told me when I started learning to code. Something that would have saved me from a mistake I didn’t even know I was making for weeks. Something that sits at the intersection of everything we build and everything that can go wrong with it.</blockquote><h3>The Moment I Understood Why This Matters</h3><p>I built my first real project, “A portfolio website”, and I was proud of it. Clean design. Fast load time. All my projects are linked. My GitHub is connected. Everything worked exactly the way I intended.</p><p>Then I tried to hack it.</p><p>I found an API key sitting in a public JavaScript file. In a public GitHub repository. Visible to the entire internet. For weeks.</p><p>I hadn’t been careless. I hadn’t been lazy. I had followed a tutorial, done everything it said, and deployed confidently. The tutorial just never mentioned that putting credentials in frontend JavaScript is like writing your house key on the front door.</p><p>That’s the problem. Not malice. Not laziness. Just a gap in education that almost every developer has — and almost nobody talks about until something goes wrong.</p><h3>The Education Gap Nobody Admits Exists</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*X5tQM6Y8yaSnTiwwK31MhA.png" /><figcaption>University lecture hall, student looking confused at complex code on projector screen, dramatic lighting, no faces.</figcaption></figure><p>Think about what a typical computer science curriculum teaches you.</p><p>Data structures. Algorithms. Object-oriented programming. Database design. Web development. Software engineering principles. All of it focused on one thing: how to build.</p><p>Now think about what it rarely teaches you.</p><p>How things break. How people abuse systems. What happens when your code encounters someone who is actively trying to make it do something you didn’t intend?</p><p>I’m not blaming universities for this. The field is enormous, and curriculum time is finite. But the consequence is real: developers graduate knowing how to build systems and having almost no framework for thinking about how those systems fail under adversarial conditions.</p><p>And adversarial conditions are the default on the internet.</p><p>Bots will submit every form you build. Scanners will probe every API you expose. Every piece of code you deploy will eventually be looked at by someone trying to find a way through it. Not because you’re important or your project is a target — just because that’s how the internet works. Automated tools scan everything, constantly.</p><p>The question isn’t whether someone with bad intentions will test your code. The question is whether it will pass that test.</p><h3>Reason 1: You are already writing vulnerable code.</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9LFec-RRwWDOuuc5nFsvxQ.png" /><figcaption>Code editor with red highlighted vulnerable lines, dark theme, warning icons visible, no faces, close up</figcaption></figure><p>I don’t say this to be harsh. I say it because it was true of me, and it’s true of almost every developer who hasn’t specifically studied security.</p><p>Here’s a list of common mistakes that beginner developers make without knowing they’re mistakes:</p><p><strong>Exposed credentials:</strong><br>Putting API keys, database passwords, or secret tokens directly in source code. Then, push that code to a public GitHub repository. The key is now public. It will be found. Automated tools like truffleHog scan GitHub continuously, looking for exactly this.</p><p><strong>Missing input validation:</strong><br>Building a form that accepts whatever the user types and processes it without checking whether it makes sense. A text field that accepts &lt;script&gt;alert(&#39;xss&#39;)&lt;/script&gt; a name. An email field that accepts malicious SQL injection input as a valid address. Not validating is the default state for code written by someone who has never considered what an attacker might type.</p><p><strong>Trusting the frontend:</strong><br> Putting security checks only in JavaScript that runs in the browser. Any attacker can bypass browser-side validation by sending requests directly to your server. If your only check is “is this email formatted correctly” in JavaScript, that check doesn’t exist for anyone who sends a raw HTTP request.</p><p><strong>Default credentials:</strong><br> Deploying a database or admin panel with the default username and password because you were focused on getting the feature working and forgot to change it. Default credentials for common software are publicly documented. They’re the first thing automated scanners try.</p><p><strong>Verbose error messages:</strong><br>Letting your application show detailed error messages in production — stack traces, file paths, database query strings. Every piece of information an error message reveals is a piece of information an attacker can use to understand your system.</p><p>None of these requires sophisticated knowledge to exploit. Most of them can be found with free tools in minutes. And all of them are things you would never do if someone had explained why they were dangerous before you started building.</p><h3>Reason 2: Attackers Think Differently — And You Need to Too</h3><p>This is the hardest thing to teach and the most important thing to learn.</p><p>As a developer, you think about what your code should do. You design the happy path — the sequence of events where the user does what you expect, inputs what you expect, and gets the result you intended.</p><p>An attacker thinks about everything else.</p><p>What happens if I input ten thousand characters into this field? What happens if I send this request five hundred times per second? What if I modify the request between the browser and the server? What if I’m not using a browser at all? What if I put a single quote in this field? What if I put a null byte? What if I upload a file with a .jpg extension that is actually a PHP script?</p><p>None of those is the happy path. All of them are things that will happen to any application that exists on the internet long enough.</p><p>The shift from developer thinking to security thinking is a shift from “what does this do” to “what could this do that I didn’t intend.” It’s not a complicated shift once you make it. But you have to make it consciously, and it helps enormously to understand the specific techniques attackers use — because then you know exactly what questions to ask.</p><blockquote><em>You cannot defend what you don’t understand how to attack. This isn’t about becoming a hacker. It’s about understanding the full lifecycle of your code.</em></blockquote><h3>Reason 3: It Makes You a Better Developer in Every Way</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JdmtTBuYXnudRgwMz4tLZw.png" /><figcaption>Developer at dual monitor setup, one screen shows clean code,the other shows security scan results, dark ambient room, no faces</figcaption></figure><p>Here’s something I didn’t expect when I started studying security: it didn’t just make my code more secure. It made my code better in ways that have nothing to do with security.</p><p><strong>It taught me to validate everything.</strong></p><p>Not just for security purposes — but because unvalidated input causes bugs, crashes, and unexpected behavior regardless of whether someone is attacking you. The habit of asking “what if this input is wrong?” makes your code more robust across the board.</p><p><strong>It taught me to understand what’s actually happening.</strong></p><p>When you study how SQL injection works, you actually understand how databases construct and execute queries. When you study XSS, you understand how browsers parse HTML and execute JavaScript. When you study buffer overflows, you understand memory layout. Security education is, at its core, education about how systems actually work at a level below the abstractions most developers operate in.</p><p><strong>It taught me to think about edge cases.</strong></p><p>Security thinking is extreme edge case thinking. What’s the worst possible input? What’s the most unexpected behavior? What’s the thing that breaks the assumption the code was built on? Developers who think this way write software that handles failure gracefully instead of catastrophically.</p><p><strong>It made me a more valuable hire.</strong></p><p>Most junior developers can build features that work when everything goes right. Far fewer can build features that work when everything goes wrong — when the input is malicious, when the user is adversarial, when someone is actively trying to break it. That distinction matters to employers in a way that becomes more significant every year.</p><h3>Reason 4: The Industry Requires It Now — Whether or Not Your Job Title Says “Security”</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HZ71xK2pmiHNxBI6kyJa6A.png" /><figcaption>Job posting on laptop screen showing cybersecurity requirements, modern office desk, soft light, no faces</figcaption></figure><p>There’s a concept called DevSecOps — the practice of integrating security into every stage of software development rather than treating it as a separate phase at the end. It used to be a forward-thinking approach. Now it’s standard practice at any company that takes its infrastructure seriously.</p><p>What that means practically: it’s no longer enough to have a security team that reviews code before it ships. Companies need every developer on their team to write with security in mind from the beginning. Security reviews catch some things. They don’t catch everything. The only way to catch everything is to have developers who think about security while they’re building.</p><p>This shows up in hiring. Job postings for “software engineer” roles at serious companies increasingly list security awareness as a requirement — not a nice-to-have. Understanding OWASP. Familiarity with secure coding practices. Experience with penetration testing tools. These used to be niche requirements for security-specific roles. They’re becoming baseline expectations for developers.</p><p>The cybersecurity skills gap is enormous — over three and a half million unfilled positions globally as of 2025. But equally real is the shortage of developers who understand security. Companies are looking for people who can do both. Those people get hired faster and paid more.</p><blockquote><em>The best time to learn security was before you wrote your first function. The second best time is right now.</em></blockquote><h3>Reason 5: Your Users Are Trusting You With Something Real</h3><p>This is the one that I find myself thinking about most.</p><p>When someone fills out the contact form on a website, they’re trusting the developer with their name and email address. When someone creates an account, they’re trusting you with a password they probably use in other places, too. When someone makes a purchase, they’re trusting you with financial information.</p><p>They have no way of knowing whether that data is stored securely. They have no way of knowing whether your form validates input, whether your database is configured correctly, whether your API keys are in a .env file or sitting in your public JavaScript. They click submit and trust that the person who built this knew what they were doing.</p><p>Most of the time, they’re trusting someone who never thought about any of that.</p><p>I’m not saying this to make anyone feel guilty. I’m saying it because I think it matters morally, not just technically. When you deploy code that other people use, you have accepted a responsibility for their data and their experience. Security is part of that responsibility,y whether you acknowledge it or not.</p><p>The developers who understand this write better software. Not because they’re more talented. Because they’re asking different questions while they build.</p><blockquote><em>Writing code is easy. Writing code that respects the people who use it takes intentionality. Security is part of that intentionality.</em></blockquote><h3>Where to Actually Start</h3><p>I know this can feel overwhelming. Cybersecurity is a vast field,d and it’s easy to look at the full scope of it and not know where to begin.</p><p>Here’s the thing: you don’t need to become a security expert. You don’t need to do a career change. You just need to add a security lens to what you’re already doing as a developer. An hour a week, consistently, is enough to change how you build.</p><p><strong>Week 1–2: Get the vocabulary</strong><br> Cisco’s Introduction to Cybersecurity is free, takes a few weeks, and gives you the baseline vocabulary you need to understand everything else. Do it.</p><p><strong>Week 3–4: Understand the most common threats</strong><br> Read the OWASP Top 10. It’s a list of the ten most critical web application security risks, with clear explanations and examples. Bookmark it. Refer back to it every time you build a new feature.</p><p><strong>Week 5–6: Try to break something you built</strong><br> Take a project you’ve already built. Open DevTools. Read your JavaScript files like an attacker would. Run your URL through securityheaders.com. Search your codebase for any hardcoded credentials. You might find nothing. You might find something that surprises you.</p><p><strong>Ongoing: Read one write-up per week.</strong><br> HackTheBox writeups, bug bounty reports, CVE explanations. One per week. You’ll understand maybe 30% of it at first. That percentage will grow every week.</p><p><strong>When you’re ready: TryHackMe</strong><br> Gamified, beginner-friendly, and designed specifically for people learning security. The Pre-Security path is built for developers who want to understand the fundamentals without committing to a full security career change.</p><p>None of this is a huge time investment. All of it compounds.</p><h3>The Real Argument, Simply</h3><p>Here it is, as simply as I can put it.</p><p>Every developer writes code that runs on systems used by real people. Those systems can be broken. Those people can be hurt — financially, professionally, personally — when they are. The person who built the vulnerable system is responsible for that, whether they knew about the vulnerability or not.</p><p>Understanding how systems break is not optional. It’s not a specialty. It’s part of the job — the part that nobody talks about until something goes wrong.</p><p>I’m a first-year CSE student. I haven’t mastered any of this. I’m still in the early phases of a learning curve that will take years to climb. But I’ve already caught vulnerabilities in my own code that I would have shipped without a second thought six months ago.</p><p>That’s what a little security education does. It makes the invisible visible. It turns blind spots into checkpoints. It changes the questions you ask while you build.</p><p>Start now. Your future users will thank you. Your future self will thank you.</p><p>And honestly, it’s just more interesting than people make it sound.</p><p><em>Saharia Hassan Safin — CSE student at Daffodil International University, currently learning cybersecurity and building secure web apps. Writing about the intersection of development and security from a beginner’s honest perspective. Find projects on </em><a href="https://github.com/Safin313-REBORN"><em>GitHub</em></a><em> or connect on </em><a href="https://www.linkedin.com/in/saharia-hassan-safin/"><em>LinkedIn</em></a><em>. You can also check out my </em><a href="https://safin313-reborn.github.io/"><em>Portfolio</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43e176ad57fd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/ai-security-hub/why-every-developer-should-learn-cybersecurity-before-writing-their-first-line-of-code-43e176ad57fd">Why Every Developer Should Learn Cybersecurity Before Writing Their First Line of Code</a> was originally published in <a href="https://medium.com/ai-security-hub">AISecHub</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Tried to Hack My Own Portfolio Website — Here’s What Happened]]></title>
            <link>https://javascript.plainenglish.io/i-tried-to-hack-my-own-portfolio-website-heres-what-happened-845f18206bd5?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/845f18206bd5</guid>
            <category><![CDATA[beginner]]></category>
            <category><![CDATA[web-security]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[students]]></category>
            <category><![CDATA[ethical-hacking]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Sat, 06 Jun 2026 14:44:24 GMT</pubDate>
            <atom:updated>2026-10-25T17:00:24.469Z</atom:updated>
            <content:encoded><![CDATA[<h4>A beginner’s honest attempt at breaking their own creation — and what I found, which I never expected</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5ni59XUktFZ0TPOldRTOjw.png" /><figcaption>Portfolio website on laptop screen, dark room, soft blue glow, minimal desk setup, no faces</figcaption></figure><blockquote>September 2025. I had just finished building my portfolio site. It had a contact form, a projects section, my GitHub links. I was proud of it. I had spent weeks on it — tweaking the CSS, fixing the layout on mobile, making sure every link worked. Then a thought hit me — “Can I break this?”</blockquote><h3>Why I Even Tried This</h3><p>I want to be honest about where I was mentally when this happened.</p><p>I was a 1st-year CSE student. I had just completed the <a href="https://www.netacad.com/courses/introduction-to-cybersecurity">“Cisco Introduction to Cybersecurity”</a> course. I was watching YouTube videos every evening — SQL injection demos, XSS payloads, Nmap tutorials, Burp Suite walkthroughs. I was consuming security content like someone who had just discovered a new language.</p><p>But everything I was learning felt abstract. Safe. Theoretical. I could watch someone demonstrate a SQL injection in a controlled lab environment and understand the concept perfectly. But I had never touched anything real, never done anything practically.</p><p>Then I looked at my own portfolio site sitting on GitHub Pages and thought — that’s a real website. I built it. I own it. Nobody can arrest me for testing it. Why am I practicing on fake labs when I have something real right in front of me?</p><p>That was the mindset. Curious, slightly overconfident, and genuinely not sure what I would find.</p><h3>The Setup — What I Actually Built</h3><p>My first portfolio was a static site hosted on “GitHub Pages”. Here’s what it had:</p><ul><li>A home section with my name and a brief bio</li><li>A projects section linking to my GitHub repository</li><li>A skills section listing my languages and tools</li><li>A contact form with name, email, and message fields</li><li>Basic JavaScript for some animations</li></ul><p>No backend server. No Node.js. No PHP. No database. Just HTML, CSS, and JavaScript files served directly from a GitHub repository.</p><p>I had built it to practice my skills in HTML, CSS, and JavaScript. It looked clean. It loaded fast. On the surface, it seemed professional.</p><p>What I didn’t know — what I was about to find out — was that “looks professional” and “is secure” are two completely different things.</p><h3>$ whoami — What I Knew at That Point</h3><p>Before I tell you what I did, let me be brutally honest about my skill level going into this:</p><pre>Knowledge base : Cisco Intro to Cybersecurity ✓<br>                 Basic Linux terminal commands ✓<br>                 Competitive programming (Beecrowd problems) ✓<br>                 Watched ~40 hours of YouTube security content ✓<br><br><br>Tools I&#39;d used : Nmap (basic scans only)<br>                 Browser DevTools (inspect element level)<br>                 Kali Linux (installed, broken, reinstalled twice)<br><br>Real pentesting experience : Zero<br>Professional security training : Zero<br>Confidence level : Dangerously, embarrassingly high</pre><p>I want to be clear about this because I see a lot of security content that makes it seem like you need to be an expert before you can find anything. You don’t. Sometimes you just need to look deeply.</p><p>But equally, I had no idea what I was doing in the way a professional would. Everything I tried was based on YouTube tutorials, reading, and sometimes the help of AI. This is not a professional penetration test. This is a curious student with too much free time and a Linux terminal.</p><h3>The Methodology — Thinking Like an Attacker for the First Time</h3><p>This was the most important shift I had to make. I had to stop thinking like the person who built the site and start thinking like someone who wanted to break it.</p><p>As the builder, I thought: the contact form takes input, formats it, and sends an email.</p><p>As an attacker, I had to think: “The contact form takes input. What input was it designed for? What input was it not designed for? What happens when I give it something unexpected?”</p><p>That question, “What happens when I give it something unexpected ?” is the foundation of almost all offensive security work.</p><p>I opened a fresh browser window. Opened DevTools with the F12 button. I started looking at my own site like a stranger would.</p><p><strong>Step 1: Map the attack surface</strong></p><p>What parts of this site accept input?</p><ul><li>The contact form: name, email, message fields</li><li>The URL itself: could I manipulate query parameters?</li><li>Any JavaScript files: what are they doing, what data do they handle?</li></ul><p>For a static portfolio site, the attack surface is small. But small doesn’t mean zero.</p><p><strong>Step 2: Read the source code</strong></p><p>Right-click → View Page Source. I read every line of HTML. Then I opened the Network tab in DevTools and watched what happened when I loaded the page and submitted the form. Where did requests go? What data was being sent?</p><p><strong>Step 3: Look at the JavaScript files</strong></p><p>This is where things started getting interesting. But I’ll get to that.</p><h3>Phase 1 — The XSS Attempt</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gKFn90ZoOwa8TrvcC9rZKA.png" /><figcaption>HTML code on dark screen, browser devtools open, green and white text, close up, no faces.</figcaption></figure><p>First attempt. The classic beginner move.</p><p>I typed this into the name field of the contact form:</p><pre>&lt;script&gt;alert(&#39;hacked&#39;)&lt;/script&gt;</pre><p>Cross-Site Scripting (XSS) is one of the most common web vulnerabilities. The idea is simple: if a website accepts user input and displays it on the page without sanitizing it, you can inject JavaScript that runs in other users’ browsers. In a real attack, this could steal cookies, redirect users to malicious sites, or log keystrokes.</p><p>I hit submit.</p><p>Nothing. The page didn’t change. No alert box. No error message. Nothing.</p><p>I tried a few variations:</p><pre>&lt;img src=&quot;x&quot; onerror=&quot;alert(&#39;xss&#39;)&quot;&gt;<br>&lt;svg onload=&quot;alert(&#39;xss&#39;)&quot;&gt;<br>javascript:alert(&#39;xss&#39;)</pre><p>Still nothing visible.</p><p>At this point, I had two possible explanations: either the site was sanitizing my input correctly, or the input wasn’t being reflected to the page at all. I needed to find out which.</p><p>Since this was a static site with a contact form, the form data wasn’t being displayed back on the website. It was being sent somewhere — presumably to my email. Without a backend to reflect the input, stored XSS wasn’t possible here.</p><p>First dead end. Moving on.</p><h3>What I Actually Found</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*a6KslnGsa3sY-cGNqMBmrw.png" /><figcaption>API key exposed in code editor, red highlight, dark theme VS Code, warning icons, no faces.</figcaption></figure><p>Sitting in one of my JavaScript files, in plain text, was an API key.</p><p>I had integrated a third-party service into my portfolio — something small, for a feature I thought was cool. To make it work, I needed an API key. The tutorial I followed showed me how to put the key directly in the JavaScript file.</p><p>What the tutorial did not mention: JavaScript files served by a website are publicly accessible. Anyone can view them. And my portfolio was on a public GitHub repository, which meant the key was also visible in my commit history.</p><p>The DevTools Console also showed me several other issues:</p><pre>⚠️  Mixed content warning<br>        → Site loaded over HTTPS but making HTTP requests<br>⚠️  API key exposed in /assets/js/main.js<br>        → Hardcoded credential visible in public source<br>⚠️  No Content-Security-Policy header detected<br>        → Browser has no instructions on what scripts to trust<br>⚠️  Form submitting data without client-side validation<br>        → Any input accepted and forwarded without checking</pre><p>None of these was the dramatic SQL injection or XSS I had been hoping to find. But they were real vulnerabilities — the kind that cause actual damage in the real world.</p><p>The exposed API key was the most serious. Depending on what the key was for, someone could have:</p><ul><li>Used my API quota, potentially racking up charges</li><li>Accessed the data I had stored with that service</li><li>Used the key as a stepping stone to other parts of my account</li></ul><p>I had built a site that looked professional. I had a nice design. My projects were linked. My skills were listed. And I had left a key to part of my infrastructure sitting in public source code.</p><h3>What Could Have Gone Wrong — The Realistic Threat</h3><p>Let me be specific about this, because I think it’s important.</p><p>People assume attackers are sophisticated. Sometimes they are. But a lot of the damage done to small projects and personal sites comes from automated scanners — bots that crawl GitHub, look for exposed API keys and credentials, and immediately attempt to use them.</p><p>Tools like <strong>truffleHog</strong> and <strong>git-secrets</strong> exist specifically to scan repositories for exposed credentials. These tools are used by security researchers — and by attackers. If your key is in a public repo, it’s not a question of whether someone will find it. It’s a question of when.</p><p>In my case, the key was for a relatively low-stakes service. The worst realistic outcome was someone burning through my free tier quota. But the principle is the same whether the key is for a weather API or for AWS — once it’s public, it’s compromised.</p><p>I also want to note: deleting the file or removing the key from the current version of your code is not enough. Git keeps history. The key lives in every commit where it exists. You have to rotate the key — generate a new one and invalidate the old one — regardless of whether you remove it from the code.</p><p>I did both. Removed it from the code. Moved it to an environment variable pattern. Rotated the key with the service provider.</p><p>30 minutes of work to fix something that could have caused real problems.</p><h3>The Full Picture — Security Audit Results</h3><p>Here’s an honest summary of what I found, rated by severity:</p><p><strong>Critical:</strong></p><ul><li>API key exposed in public JavaScript file and Git history ← fixed</li></ul><p><strong>Medium:</strong></p><ul><li>No Content Security Policy header set</li><li>Mixed content warnings (HTTP requests from HTTPS page)</li><li>Form input was not validated before submission</li></ul><p><strong>Low:</strong></p><ul><li>No rate limiting on form submissions (could be spammed)</li><li>JavaScript libraries loaded from CDN (Content Delivery Network) without Subresource Integrity checks</li></ul><p><strong>Informational:</strong></p><ul><li>The site has no robots.txt</li><li>No security.txt file (this is a standard way to tell researchers how to report vulnerabilities)</li></ul><p>For a personal portfolio site, most of these are low stakes. But this is the same checklist that applies to production applications used by thousands of people. Learning to see these issues on a small, safe project is how you build the habit of catching them everywhere.</p><h3>The Lesson That Hit Different</h3><p>I came looking for dramatic hacks. I came expecting to find some clever vulnerability that I could write about, feeling like a genius.</p><p>Instead, I found a careless mistake that I had made myself, weeks earlier, without realizing it.</p><p>That is real security work.</p><p>It’s not cinematic. It doesn’t look like the movies. It’s mostly careful reading, methodical checking, and finding the thing that was hiding in plain sight because nobody looked.</p><blockquote><em>The most dangerous vulnerabilities aren’t the sophisticated ones. They’re the obvious ones that everyone was too busy to check.</em></blockquote><p>The Cisco cert taught me that threats exist. The YouTube tutorials taught me what the techniques look like. But actually pointing those techniques at something I built — something real — taught me something neither of those could:</p><blockquote>Security isn’t about other people’s mistakes. It’s about you, too.</blockquote><h3>What I’d Do Differently Now</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Xv-OISTeOSZPKOmju9Qzg.png" /><figcaption>Security checklist on dark background, glowing green checkboxes, minimal flat design, no text</figcaption></figure><p>Before deploying any project now, I run through this checklist:</p><p><strong>Code &amp; Credentials:</strong></p><ul><li>Grep the entire codebase for API keys, passwords, and tokens</li><li>Confirm .env files are in .gitignore before the first commit</li><li>Use environment variables for all secrets — never hardcode</li><li>Scan git history with truffleHog before making a repo public</li></ul><p><strong>Headers &amp; Configuration:</strong></p><ul><li>Set Content Security Policy headers</li><li>Ensure all requests use HTTPS</li><li>Add X-Frame-Options and X-Content-Type-Options headers</li><li>Check results at securityheaders.com</li></ul><p><strong>Input &amp; Forms:</strong></p><ul><li>Validate all form inputs client-side AND server-side</li><li>Add rate limiting to form submissions</li><li>Sanitize any input that gets displayed back to users</li></ul><p><strong>General:</strong></p><ul><li>Run a basic Nmap scan on your own domain</li><li>Read through your JavaScript files like an attacker would</li><li>Check the browser console for warnings on every page</li></ul><p>None of this takes more than an hour. Most of it takes minutes. And it catches the vast majority of issues that beginners accidentally introduce.</p><h3>Tools I Used (and What They Actually Do)</h3><p>Since I mentioned several tools, let me be specific about what they are and how I used them:</p><p><strong>Browser DevTools (Chrome/Firefox)</strong> are built into every browser. Press F12 button. The Sources tab shows every file loaded by the page. The Network tab shows every request made. The Console shows errors and warnings. This is your first and most important tool — free, always available, no installation required.</p><p><strong>Nmap</strong> is a network scanning tool. I ran nmap -sV yoursite.com to see what ports were open and what services were running. For a GitHub Pages site, the results were minimal, but this is essential for any site running its own server.</p><p><strong>securityheaders.com is a</strong> free website where you enter your URL, and it checks your HTTP security headers. Instant results, clear explanations, no setup required. I wish I had known about this earlier.</p><p><strong>truffleHog (learned about after):</strong> A tool that scans Git repositories for secrets and credentials. I didn’t use this during my initial test — I found the API key manually through DevTools. But after researching, this is now part of my checklist before making any repo public.</p><h3>Where I Am Now</h3><p>I’m still a beginner. I want to be clear about that. I’m a CSE student, and I have years of learning ahead of me.</p><p>But that September evening changed something. Before it, security felt like a separate discipline — something that experts did to protect systems that other people built. After it, I understood that security is just part of building. It’s not a specialty layer you add on top. It’s a set of questions you ask at every step.</p><p>What does this input do when it’s unexpected? Who can see this file? What happens if someone finds this key? How does this break when someone tries to break it?</p><p>Those questions now run in the background every time I write code. That’s not expertise. That’s just a habit. And habits start with a single moment of actually looking.</p><blockquote><em>Build something. Then try to break it. Then fix what you find. Then build something better. That’s the real curriculum. No course teaches it. You have to do it yourself.</em></blockquote><h3>Try It Yourself</h3><p>If you’ve built anything — a portfolio site, a small web app, a landing page — try this:</p><ol><li>Open it in a browser. Press F12.</li><li>Go to the Sources tab. Read your JavaScript files.</li><li>Go to the Console tab. Read every warning.</li><li>Go to the Network tab. Watch what happens when you submit a form.</li><li>Run your URL through securityheaders.com.</li><li>Search your code for any API keys, passwords, or tokens.</li></ol><p>You might find nothing. That’s fine — that means you already have good habits.</p><p>Or you might find something that surprises you.</p><p>Either way, you’ll understand your own work better than you did before you looked.</p><p>onSaharia Hassan Safin — CSE student at Daffodil International University, currently obsessed with cybersecurity and building (and breaking) things. Find projects on <a href="https://github.com/Safin313-REBORN">GitHub</a> or connect on <a href="https://www.linkedin.com/in/saharia-hassan-safin/">LinkedIn</a>.<em> You can also check out my </em><a href="https://safin313-reborn.github.io/"><em>Portfolio</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=845f18206bd5" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/i-tried-to-hack-my-own-portfolio-website-heres-what-happened-845f18206bd5">I Tried to Hack My Own Portfolio Website — Here’s What Happened</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I’m a 1st-year CSE Student Learning Cybersecurity — Here’s What No One Told Me.]]></title>
            <link>https://javascript.plainenglish.io/im-a-1st-year-cse-student-learning-cybersecurity-here-s-what-no-one-told-me-3926d5a39471?source=rss-a0ed3add2c50------2</link>
            <guid isPermaLink="false">https://medium.com/p/3926d5a39471</guid>
            <category><![CDATA[study]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[hacking]]></category>
            <category><![CDATA[cybersecurity]]></category>
            <category><![CDATA[linux]]></category>
            <dc:creator><![CDATA[Saharia Hassan Safin]]></dc:creator>
            <pubDate>Tue, 02 Jun 2026 17:00:37 GMT</pubDate>
            <atom:updated>2026-10-25T16:57:59.172Z</atom:updated>
            <content:encoded><![CDATA[<h4>The gaps between the course syllabus and the real world</h4><blockquote>I enrolled at Daffodil International University in 2025 as a CSE student. I thought cybersecurity meant watching cool hacking scenes from movies and typing fast. I was wrong and the real thing is so much more interesting.</blockquote><figure><img alt="A detailed cartoon illustration of the student Safin’s comprehensive cybersecurity learning and development roadmap in a tech-filled room, now featuring a custom security-themed logo on his hoodie." src="https://cdn-images-1.medium.com/max/1024/1*7dueagxb2yly33vKSdJHnQ.png" /></figure><h3>The moment I got serious</h3><p>It started with a simple question: <em>“How does a website get hacked?”</em></p><p>I Googled it. Then I fell into a 3-hour rabbit hole of SQL injection demos, XSS payloads, and packet sniffers. That night, I realized my university syllabus teaches me how to <em>build</em> things. Nobody was teaching me how to <em>break</em> them. And you can’t truly defend what you don’t know how to attack.</p><h3>What no one told me #1: Your first cert will humble you</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lOp_WEsFDJJXHxqkjzlmJw.png" /><figcaption>Cisco certification on laptop screen, student at desk, warm desk lamp, notebook open beside laptop, no faces</figcaption></figure><p>I completed the Cisco Introduction to Cybersecurity course expecting to feel like a hacker. Instead, I felt like I had just learned the alphabet of a language with 10,000 words.</p><p>But that wasn’t the worst part.</p><p>After the cert, I went to YouTube — watched guide after guide, tutorial after tutorial. Half the time, I had no idea what the instructor was even doing. Commands flying by, tools I’d never heard of, concepts that assumed I already knew three other concepts I hadn’t learned yet.</p><p>It was overwhelming. I almost quit.</p><p>Then something clicked. Once I got the basics — what a network actually is, what a port does, why encryption exists — the YouTube videos started making sense. The same tutorials I couldn’t follow before suddenly felt obvious.</p><p>The cert is excellent. Don’t skip it. But treat it as the floor, not the ceiling. It teaches you <em>that</em> threats exist. Hours of confusion on YouTube teach you <em>why</em> they work.</p><p><strong>The confusion is the learning. Don’t skip it.</strong></p><h3>What no one told me #2: C is still king</h3><p>Everyone told me to learn Python for cybersecurity. That’s true. But learning C first — which I did through competitive programming on Beecrowd — gave me something Python can’t: I understand memory.</p><p>Buffer overflows, pointer arithmetic, stack vs heap — these aren’t abstract concepts to me. They’re things I’ve written by hand. When I read a CVE report now, I actually understand the bug.</p><p>One thing I’d recommend to every CS student: start with <strong>C</strong>. Learn how memory works, how programs run, and what happens under the hood.</p><p>Then move to <strong>C++</strong> to build strong problem-solving and object-oriented programming skills.</p><p>After that, learn <strong>Python</strong>. You’ll appreciate its simplicity much more when you already understand what’s happening behind the scenes.</p><p>Python makes you productive. C teaches you how computers think.</p><p>If you’re a CSE student: don’t skip C.</p><h3>What no one told me #3: Linux is not optional</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kodhnFTqBZtD2b86Cjm1Ag.png" /><figcaption>Dark terminal screen with green text, multiple command line windows open, dramatic lighting, no faces, cinematic close-up</figcaption></figure><p>I used Windows my whole life. One month after getting my laptop, I heard about Linux. Curious, I tried installing Kali — and immediately broke my boot.</p><p>Spent hours fixing it. Got it working. Broke it again. Fixed it again. Then broke it a third time, doing something stupid.</p><p>But here’s the thing — every break taught me something Windows never could. How bootloaders work. How partitions work. How the OS actually <em>talks</em> to hardware. You don’t learn that by clicking “Next, Next, Finish.”</p><p>After enough cycles of breaking and fixing, something shifted. I wasn’t just <em>using</em> Linux anymore — I had built a foundation from scratch, through pain. I had touched almost every flavor: Kali, Ubuntu, Parrot, Arch attempts, live USBs, dual boots, the whole mess.</p><p>Now I live in the terminal. netstat, nmap, tcpdumpCustom bash scripts — these aren&#39;t scary commands anymore. They&#39;re muscle memory.</p><p>The painful truth: <strong>you don’t learn Linux by reading about it. You learn it by breaking it.</strong></p><p>So break it. On purpose. Then fix it. What no one told me #4: The community matters more than the courses</p><p>I learned more from:</p><ul><li>Read write-ups on HackTheBox and TryHackMe</li><li>Watching IppSec on YouTube</li><li>Following security researchers on GitHub</li></ul><p>… rather than from any single course.</p><p>Find your people. Join CTF teams. Post what you learn. Build in public.</p><h3>The Roadmap I Wish Someone Gave Me</h3><p>When I started, I had no map. Just random YouTube videos, random courses, random tools — no idea what to learn first or why.</p><p>So here’s what I’ve figured out, the hard way:</p><p><strong>Phase 1 — Foundation</strong> <em>(where I am now):</em> Get the Cisco cert. Learn Linux until breaking it feels normal. Understand how networks actually work — IP, DNS, ports, TCP/UDP. Write basic Python. This phase feels slow. Do it anyway.</p><p><strong>Phase 2 — Core Skills:</strong> TryHackMe’s beginner paths will change how you think. Learn Nmap and Wireshark. Understand how the web works under the hood — HTTP, cookies, sessions. Then study the OWASP Top 10 like your career depends on it. It does.</p><p><strong>Phase 3 — Offense + Defense:e</strong> HackTheBox. Burp Suite. Metasploit. Start solving CTF challenges — easy boxes first. You’ll fail. That’s the point.</p><p><strong>Phase 4 — Certifications that matter:</strong> CompTIA Security+ for credibility. eJPT for practical pentesting. Google’s Cybersecurity cert on Coursera; if budget is tight, financial aid is available.</p><p><strong>Phase 5 — Specialize and get paid.</strong> Pick a track: pentesting, SOC analyst, bug bounty, AppSec. Write CTF writeups. Post on GitHub. Blog about what you learn. The OSCP is the dream — but that’s a year 3 problem.</p><p><em>I’m at Phase 1. But I’m moving.</em></p><h3>What No One Told Me #4: The Community Is the Real Curriculum</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Rvhol_XDbPYlsquQkHrm5w.png" /><figcaption>Multiple browser tabs open with security writeups and forums, dark room, monitor glow, coffee cup on desk, no faces.</figcaption></figure><p>At some point, I realized something uncomfortable: I was learning more from strangers on the internet than from any structured course.</p><p>The cybersecurity community shares everything. CTF writeups where someone walks through exactly how they solved a challenge. Bug bounty reports where researchers explain the vulnerability they found and how they found it. GitHub repositories full of tools with comments explaining why each part works the way it does. YouTube channels where professional pentesters do live hacking sessions and explain their thought process out loud.</p><p>This content is free. All of it. And it’s often better than paid courses because it’s real — real targets, real findings, real thinking.</p><p>The shift for me came when I stopped treating security as something I was studying and started treating it as something I was participating in. I started reading one write-up per day. I started following security researchers whose work I found interesting. I started paying attention to CVEs when they were published and trying to understand what the vulnerability actually was.</p><p>I wasn’t contributing anything yet. I was just listening. But even just listening to the right conversations changed how I thought.</p><p>The other thing the community gave me was perspective. Seeing other beginners write about their confusion, their mistakes, their small victories — it normalized the experience. Security is hard. Everyone good at it was once completely lost. The community makes that visible in a way that formal education doesn’t.</p><blockquote><em>Don’t study in silence. Find the community. Read the writeups. Watch the livestreams. Follow the researchers. The curriculum is out there — it’s just not in a classroom.</em></blockquote><h3>What no one told me #5: Start building, not just studying</h3><p>When I created my GitHub account, I didn’t have ambitious projects or a polished portfolio. Most of my repositories were simply solutions to Beecrowd programming problems written in C.</p><p>At the time, they felt insignificant.</p><p>Looking back, they were one of the most valuable investments I made in my learning journey.</p><p>Those problem-solving exercises taught me how to think logically, break down complex problems, debug efficiently, and write code consistently. More importantly, they helped me build the habit of creating rather than just consuming content.</p><p>As my skills grew, so did my projects.</p><p>I moved from competitive programming and C-based console applications to frontend development, building interactive web applications with JavaScript, React, and Next.js. Eventually, I started developing full-stack applications using the MERN stack, working with authentication systems, REST APIs, databases, and modern development workflows.</p><p>Alongside web development, I continued exploring cybersecurity. I documented Windows CMD and PowerShell commands, studied networking concepts, and spent time understanding how systems operate behind the scenes.</p><p>Today, my GitHub reflects much more than completed assignments or personal projects.</p><p>It reflects a progression:</p><p>• Problem-solving with C<br>• Console-based applications<br>• Frontend development<br>• Full-stack web applications<br>• Cybersecurity and system administration concepts</p><p>None of these projects is revolutionary. Many of them were built while I was still learning.</p><p>That is precisely why they matter.</p><p>Recruiters, mentors, and fellow developers are not only interested in polished end products. They want to see evidence of curiosity, consistency, and growth. A GitHub profile that shows continuous learning often says more than a long list of completed courses.</p><p>Many students spend years preparing to build something.</p><p>The better approach is to build while learning.</p><p>Start with a simple project. Publish it. Improve it. Build the next one. Repeat.</p><p>Your early projects may be imperfect, but they serve an important purpose: they document your progress and help you develop real-world skills.</p><p>My GitHub is far from perfect, but it tells an honest story — from solving programming problems in C to building full-stack applications and exploring cybersecurity.</p><p>And that story is still being written.</p><p><strong>Build early. Build consistently. Learn publicly.</strong></p><h3>Where I am now</h3><p>I’m a 2nd-year student. I have a lot to learn. But here’s what I know:</p><ul><li>I understand why security matters at the code level</li><li>I’m building real projects, not just doing tutorials</li><li>I’m actively learning instead of waiting for a professor to teach me</li></ul><p>The gap between a CS graduate who studied cybersecurity and one who <em>practiced</em> it is enormous. I’m choosing to close that gap now — not in year 4.</p><h3>If you’re starting too</h3><ol><li>Get the Cisco cert — it’s free and worth it</li><li>Learn C before Python (or alongside it)</li><li>Install Linux and live in the terminal</li><li>Join TryHackMe — start with beginner rooms</li><li>Build and post publicly, even if it’s small</li></ol><p><em>I’m Saharia Hassan Safin — a CSE student at DIU, currently obsessed with cybersecurity and building secure web apps. Find my projects on </em><a href="https://github.com/Safin313-REBORN"><em>GitHub</em></a><em> or connect on </em><a href="https://www.linkedin.com/in/saharia-hassan-safin/"><em>LinkedIn</em></a><em>. You can also check out my </em><a href="https://safin313-reborn.github.io/"><em>Portfolio</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3926d5a39471" width="1" height="1" alt=""><hr><p><a href="https://javascript.plainenglish.io/im-a-1st-year-cse-student-learning-cybersecurity-here-s-what-no-one-told-me-3926d5a39471">I’m a 1st-year CSE Student Learning Cybersecurity — Here’s What No One Told Me.</a> was originally published in <a href="https://javascript.plainenglish.io/">JavaScript in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>