<?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 Srdan Borovic on Medium]]></title>
        <description><![CDATA[Stories by Srdan Borovic on Medium]]></description>
        <link>https://medium.com/@srdan_82278?source=rss-a1dc9ceea991------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*jM2TS4uClh0Ang7y</url>
            <title>Stories by Srdan Borovic on Medium</title>
            <link>https://medium.com/@srdan_82278?source=rss-a1dc9ceea991------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 15:15:50 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@srdan_82278/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[Top Beginner-Friendly Coding Platforms for Career Changers With No Tech Background]]></title>
            <link>https://medium.com/@srdan_82278/top-beginner-friendly-coding-platforms-for-career-changers-with-no-tech-background-5000593bc439?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/5000593bc439</guid>
            <category><![CDATA[beginner-friendly]]></category>
            <category><![CDATA[programming-course]]></category>
            <category><![CDATA[coding-platforms]]></category>
            <category><![CDATA[learn-to-code]]></category>
            <category><![CDATA[coding-courses]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 09:48:45 GMT</pubDate>
            <atom:updated>2026-11-16T09:50:39.684Z</atom:updated>
            <content:encoded><![CDATA[<h4>Your first platform shapes how fast you grow. Here’s how the top options compare in 2027.</h4><p>You’ve spent years building a career in retail, healthcare, teaching or finance. Now you want to move into tech, but every search for “best coding platform for beginners” returns a different list. One site swears by free courses. Another pushes a $15,000 bootcamp. A third says AI will write all the code anyway.</p><p>You’re in good company. Thousands of people with zero tech background ask the same question every month. The good news: you have more strong options than ever. The tricky part is picking one that fits your life, your budget and your goals.</p><h3>Why “beginner-friendly” means something new in 2027</h3><p>The job market has shifted. <a href="https://www.hiringlab.org/2026/07/23/the-labor-market-is-tilting-toward-seniority/">Indeed Hiring Lab data</a> shows that only 4.5% of US software development job postings in Q1 2026 targeted entry-level roles. <a href="https://digitaleconomy.stanford.edu/publications/canaries-in-the-coal-mine/">Research from the Stanford Digital Economy Lab</a> found that employment for software developers aged 22 to 25 fell nearly 20% between late 2022 and mid-2025.</p><p>That doesn’t mean the door has closed, but it does mean your first platform has to teach you to solve problems on your own.</p><p>A good beginner platform in 2027 should:</p><ul><li>Let you write real code from the first lesson</li><li>Remove setup headaches so you can focus on learning</li><li>Give you instant feedback when something breaks</li><li>Offer a clear path from basics to real projects</li><li>Use AI to explain concepts rather than hand you finished answers</li></ul><p>With that checklist in mind, let’s look at the top picks.</p><h3>1. Mimo: the best first stop for career changers</h3><p><a href="https://mimo.org/">Mimo</a> gives complete beginners a full web platform with structured career paths in Python, JavaScript, SQL, HTML, CSS and full-stack development. You choose a path in your browser and start writing code within minutes, with nothing to install or configure.</p><p>The lessons follow a simple rhythm. You learn a concept, write code right away and see the result instantly. That loop builds muscle memory fast, which matters when you’re learning after a full workday.</p><p>Mimo also has an AI assistant built into the platform. When your code throws an error, you can ask the assistant what went wrong. It explains the problem in plain language, so you understand the fix and can spot the same mistake next time.</p><p>Career changers like Mimo because each path lays out the order of topics and tracks your progress. When you only have an hour each evening, you spend it coding instead of deciding what to learn next.</p><p>You also earn a certificate from Mimo when you complete a path. Add it to your resume or LinkedIn profile to show employers the skills you’ve put time into.</p><p><strong>Best for:</strong> Anyone starting from zero who wants an interactive route into web development, Python or SQL, plus a certificate to show for it.</p><h3>2. Harvard CS50P and CS50x</h3><p>Harvard’s CS50 courses have a cult following, and for good reason. Professor David Malan teaches with energy and humor, and the problem sets push you to think like a programmer.</p><p>Students who’ve finished both courses give one piece of advice again and again: take <a href="https://cs50.harvard.edu/python/">CS50P</a> (Introduction to Programming with Python) before <a href="https://cs50.harvard.edu/x/">CS50x</a>. CS50x gets much harder around Weeks 6 and 7, and many beginners hit a wall there.</p><p>Here’s a money-saving tip. You don’t need to pay $219 for the <a href="https://www.edx.org/learn/computer-science/harvard-university-cs50-s-introduction-to-computer-science">edX verified certificate</a>. If you enroll through <a href="https://cs50.harvard.edu/">Harvard OpenCourseWare</a> and <a href="https://cs50.me/">cs50.me</a> with a free edX account, you get full access and a free verifiable certificate once you score 70% or higher on the problem sets.</p><p><strong>Best for:</strong> Fans of college-style lectures who want strong computer science foundations.</p><h3>3. University of Helsinki Python MOOC</h3><p>The University of Helsinki’s free <a href="https://programming-26.mooc.fi/">Python Programming MOOC</a> (<a href="https://www.mooc.fi/en/">mooc.fi</a>) skips videos completely. You read short text lessons and then solve lots of exercises, which an automated grading server checks.</p><p>Many self-taught programmers rate it above CS50P for absolute beginners. The steady repetition builds confidence without overloading you with theory. If you get bored easily without video, though, this format might feel dry.</p><p><strong>Best for:</strong> Readers who learn by doing many small exercises.</p><h3>4. freeCodeCamp</h3><p><a href="https://www.freecodecamp.org/">freeCodeCamp</a> offers a free, browser-based curriculum focused on web development. Its newer <a href="https://www.freecodecamp.org/learn/full-stack-developer/">Certified Full-Stack Developer Curriculum</a> includes six certifications of roughly 300 hours each, plus a final project.</p><p>That adds up to a long road. As of November 2026, <a href="https://forum.freecodecamp.org/">forum users</a> noticed that the final certification exam still showed “Coming Late 2026.”</p><p><strong>Best for:</strong> Budget-conscious beginners who want free web development content and have plenty of patience.</p><h3>5. The Odin Project</h3><p><a href="https://www.theodinproject.com/">The Odin Project</a> throws you into the deep end on purpose. You set up your own development environment, read documentation and build projects with very little hand-holding. You can choose a JavaScript track or a Ruby on Rails track, and JavaScript is the more popular pick.</p><p>Progress through the <a href="https://www.theodinproject.com/paths/foundations/courses/foundations">Foundations course</a> can feel slow. Learners often say the struggle is what makes the skills stick. Most need a year or more to finish.</p><p><strong>Best for:</strong> Self-starters who are happy to trade speed for depth.</p><h3>6. Scrimba</h3><p><a href="https://scrimba.com/">Scrimba</a> records instructors’ code as editable text inside its video lessons. You can pause the lesson at any moment, change the code and run it. The format gets frequent praise in JavaScript learning communities.</p><p>The free tier includes 24 courses, including a well-reviewed 9-hour <a href="https://scrimba.com/learn-javascript">JavaScript course</a>. <a href="https://scrimba.com/pricing">Scrimba Pro</a> costs $49 a month or $294 a year in the US. Some 2026 <a href="https://www.trustpilot.com/review/scrimba.com">Trustpilot reviewers</a> complained about annual plans renewing without a reminder email, so set a calendar alert before your renewal date.</p><p><strong>Best for:</strong> Visual learners interested in frontend development.</p><h3>7. Boot.dev</h3><p><a href="https://www.boot.dev/">Boot.dev</a> turns backend development into a game with XP, streaks and quests. Its courses cover Python, Go, SQL, Linux, Git and more. The <a href="https://www.boot.dev/pricing">annual plan</a> costs $399 and comes with a 30-day money-back guarantee.</p><p>Reviewers like the early Python and Git courses. Some paying learners, though, describe a mid-course “fall-off,” where the challenges get much harder than the lessons that come before them.</p><p><strong>Best for:</strong> Aspiring backend developers who get a kick out of gamification.</p><h3>8. Dataquest and DataCamp</h3><p>If you’re aiming for data analytics or data science, these two platforms come up most often.</p><p><a href="https://www.dataquest.io/"><strong>Dataquest</strong></a> has you write full code against real datasets and lets you publish your projects to GitHub. <a href="https://www.dataquest.io/pricing">Premium</a> costs $49 a month, with a 14-day refund window. Career-change comparisons tend to favor it for building portfolio-ready skills.</p><p><a href="https://www.datacamp.com/"><strong>DataCamp</strong></a> offers short videos and guided exercises across Python, SQL, Power BI and more. <a href="https://www.datacamp.com/pricing">Plans</a> start around $28 to $35 a month. The heavily guided format can make the blank editor feel scary later, and individual plans come with no refunds.</p><p><strong>Best for:</strong> Career changers targeting data roles.</p><h3>Proceed with caution: bootcamps and billing traps</h3><p>Live coding bootcamps cost anywhere from $7,000 to over $22,000. Developers and bootcamp graduates paint a gloomy picture of the industry, pointing to school closures and lawsuits from former students.</p><p>Even respected programs feel the squeeze. <a href="https://launchschool.com/results">Launch School’s published results</a> show that 37 of 60 Capstone entrants accepted job offers in 2025, down from 84 of 91 in 2022.</p><p>Read the refund terms before you subscribe anywhere.</p><h3>Two habits that make any platform work better</h3><p>Successful switchers swear by both. First, keep your day job while you learn, because quitting to study full-time carries serious risk in this market. Second, build projects tied to your current field. A former nurse who builds a shift-scheduling app stands out far more than someone with a tenth to-do list clone.</p><h3>Use AI the smart way</h3><p>AI can speed up your learning or quietly stall it. Developers on <a href="https://news.ycombinator.com/">Hacker News</a> and <a href="https://dev.to/">Dev.to</a> agree on a few ground rules:</p><ul><li>Write your first exercises by hand</li><li>Ask AI to explain errors and confusing code</li><li>Review every line of AI-generated code before you accept it</li><li>Practice explaining your own code out loud</li></ul><p>Hiring teams now test candidates in live coding sessions. If you can’t explain your code, a polished portfolio won’t save you.</p><h3>Final thoughts</h3><p>Every expert developer once stared at a blank editor with no clue where to begin. The right platform speeds things up, but only if you show up day after day.</p><p>So pick one from this list. Give it 30 days of honest effort. Then look back at how far you’ve come, you might surprise yourself.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5000593bc439" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Get Unstuck on a Coding Problem Without Asking AI for Help]]></title>
            <link>https://medium.com/@srdan_82278/how-to-get-unstuck-on-a-coding-problem-without-asking-ai-for-help-0a6836c16b31?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/0a6836c16b31</guid>
            <category><![CDATA[ai-coding]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[coding-problems]]></category>
            <category><![CDATA[ai-programming]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 11:43:12 GMT</pubDate>
            <atom:updated>2026-11-09T11:43:12.333Z</atom:updated>
            <content:encoded><![CDATA[<p>Last winter I spent an entire evening fighting a button. I clicked it, nothing happened, and the browser console said nothing.</p><p>So I pasted the component into a chatbot. The suggested fix threw a different error, so I pasted that in too, and forty minutes later my code was worse and I understood less of it than when I started.</p><p>Welcome to prompt thrashing, where the original bug sits underneath it all, eating snacks.</p><p>AI assistants have their uses. But a language model predicts likely text, so it can sound completely confident while inventing a configuration option that never existed. Every time you hand over the struggle, you also skip the part that builds your mental model of how the program behaves, and that mental model is what makes experienced developers fast.</p><p>The problem with my button, by the way, was a misspelled event name. These days I follow a straightforward process whenever I get stuck, and none of it involves a chatbot.</p><h3>Say what should happen, then what did</h3><p>Most frustrated programmers struggle to answer two basic questions: what did you expect, and what actually happened? Write both down in plain language: “The function should return three items. It returns an empty list.” That sounds too simple until you do it. Half the time, the gap between those two sentences points straight at the bug.</p><p>Stick to what you can see for now, and save theories like “the API is probably broken” for later. Then list two or three possible explanations and plan one small test that could rule out each one. Maybe the data never arrives. Maybe it arrives in an unexpected format. Maybe a filter quietly discards everything. A single print statement can eliminate a whole suspect.</p><p>Change one variable at a time. If you edit four lines at once and the bug goes away, you’ve learned nothing about which edit fixed it. Turn off any caching while you test, too, because stale data can make a perfectly good fix look like a failure.</p><p>Keep a running log in a text file, with each idea, the input you used, and the result you saw. Exhausted brains love to test the same idea three times. A written record stops that.</p><p>You can start practicing the expected-versus-actual check early, too. Mimo, for example, is a great place to learn to code, and its short exercises give you plenty of chances to guess what a line will print before you run it. When a guess misses, track down why.</p><h3>Cut the problem in half</h3><p>Bugs hide in large spaces, so make the space smaller. Pick a point halfway through the process and inspect the data there.</p><p>Say your application reads a form, validates the input, saves a record, and then displays a confirmation. Look at the saved record. If the record looks correct, the bug lives somewhere in the display logic, and if it looks wrong, the bug struck earlier. One inspection clears half of your code, and a few more soon leave you staring at the guilty line. Ten checks can cover a thousand possibilities, which feels like cheating the first time you try it.</p><p>Next, try recreating the failure in a tiny standalone file, with perhaps ten lines and no framework. Building this minimal reproducible example often solves the problem by itself. Without the surrounding noise, that null value or unexpected data type stands out right away. If the isolated version works, you’ve still learned something useful, because the trouble must come from the surrounding application or its environment.</p><p>Did the code work last week? Let Git play detective. The git bisect command applies the same halving, known as a binary search, to your commit history while you mark each version as good or bad. Once you&#39;ve found the commit, check git blame and the original commit message before you clean anything up, because odd-looking code sometimes exists for a good reason.</p><h3>Make your code talk</h3><p>Brian Kernighan once wrote, “The most effective debugging tool is still careful thought, coupled with judiciously placed print statements.” Decades later, the point still stands.</p><p>Print statements work especially well for asynchronous code, event loops, and anything sensitive to timing. Log what goes into a function, log what comes out, and label each message so you know where it came from. Then compare the output from a successful run with the output from a failing one. When you finish, delete the noise and keep the useful lines at a debug level. Future you will send a thank-you card.</p><p>An interactive debugger shines when you can’t follow the execution path through unfamiliar code. Set a breakpoint, step through line by line, and watch the variables change. Remember that pausing a program alters its timing, so race conditions can evaporate the moment you investigate them. “Heisenbug” might be the best name in software for that vanishing act.</p><p>Assertions belong in your toolkit too. Add one wherever a condition must always hold, like assert len(items) &gt; 0, and your program will stop at the exact spot where something went wrong instead of crashing 40 lines later with a baffling message.</p><h3>Go to the source</h3><p>Source code shows what the program really does. When a library misbehaves, jump to its definition in your editor and read the function. You’ll find default values the docs forgot and the exact data shapes the code expects.</p><p>Then open the project’s test files. They show how the author meant you to use the code, with real inputs and edge cases. Think of them as docs that fail loudly.</p><p>Traditional search still earns its keep if you write your queries with care. Pasting an entire stack trace into Google rarely helps, because your file paths and line numbers match nobody else’s. Keep the exception name and the core message, remove everything specific to your machine, add the library and its version number, and wrap the exact error in quotation marks.</p><p>For recently introduced bugs, skip the open web and search the project’s GitHub issues with something like repo:owner/name &quot;error message&quot; is:issue. Closed threads often hold a workaround or a maintainer explaining the underlying cause.</p><p>And search for the mechanism instead of your feature. “JavaScript floating point rounding” will beat “shopping cart total wrong” every time.</p><h3>Explain it to a duck</h3><p>Rubber duck debugging sounds like a joke, and it works anyway. Explain your code line by line, out loud, to a duck, a houseplant, or a patient friend. Inside your head, thoughts take shortcuts, but speaking out loud forces you to explain what each variable contains and why that if statement should be true. Somewhere around the fourth sentence you’ll say “and then this returns a string,” stop, and whisper something unprintable.</p><p>If you’d rather write than talk, draft a Stack Overflow post covering your environment and the steps that reproduce the problem. Plenty of authors never hit publish, because they find the answer halfway through.</p><p>When the logic has too many moving parts to hold in memory, grab a pen. Sketch the call stack, or follow an array index by hand through every iteration of a loop. Paper feels painfully slow, and that slowness prevents you from skimming past the one line that matters.</p><h3>Step away from the keyboard</h3><p>After an hour of staring at the same two lines, you can only see them one way. That’s the Einstellung effect, where your first interpretation of a problem prevents you from noticing a simpler solution. More effort won’t fix that. Neither will another coffee.</p><p>So take a walk, wash the dishes, or stand in the shower for a while. Your brain keeps sorting the problem in the background.</p><p>And if midnight has come and gone, close the laptop. Late-night you will rewrite the entire module and break three more things. Morning you will spot the missing bracket in four minutes.</p><h3>The next time you get stuck</h3><p>Give yourself 30 minutes of your own digging before you open a chat window. Write down what you expected, cut the problem in half, and see how far the evidence takes you.</p><p>Each bug you solve this way pays you twice: you get working code, and you get faster at finding the next one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0a6836c16b31" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Marketers, PMs, and Designers Are Learning to Code in the Age of AI]]></title>
            <link>https://medium.com/@srdan_82278/why-marketers-pms-and-designers-are-learning-to-code-in-the-age-of-ai-2743cf3e120a?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/2743cf3e120a</guid>
            <category><![CDATA[learning-to-program]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[learn-to-code-ai]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 21:55:19 GMT</pubDate>
            <atom:updated>2026-11-02T21:55:19.434Z</atom:updated>
            <content:encoded><![CDATA[<p>Picture a growth marketer with a simple request: sync a lead list between the CRM and the ad platform every morning. She files a ticket. Engineering marks it low priority. Three weeks later, she still exports a CSV by hand before her first coffee.</p><p>Now picture the same marketer on a Tuesday afternoon with Claude Code open in her terminal. She describes the job in plain English, reads what the agent writes, and tests it on a small batch. The sync runs before dinner.</p><p>That second scene explains a shift across tech teams. Marketers, product managers, and designers now write and ship code. Few of them plan to become software engineers. They simply got tired of watching good ideas go stale in a queue.</p><h3>The wall got shorter</h3><p>Earlier “learn to code” waves asked for a lot up front. You fought syntax errors, broken installs, and a terminal that answered every mistake with a wall of red text. Many people quit before they built anything they cared about.</p><p>AI coding agents took a sledgehammer to much of that. In February 2025, Andrej Karpathy named the new approach “vibe coding”: you talk to the machine in plain language and “forget that the code even exists.” He pitched it for throwaway weekend projects. People promptly took it to work.</p><p>Tools like Cursor, Claude Code, v0, and Bolt now handle boilerplate, library setup, and most of the syntax. With code cheaper to produce, the hard part has moved upstream: deciding what to build, spelling out how it should behave, and checking that it works.</p><h3>A working demo beats a 12-page spec</h3><p>A PRD has a blind spot. Static documents struggle to show edge cases, empty states, and what happens when the data looks weird. Those gaps tend to surface mid-sprint, when fixing them costs the most.</p><p>So PMs now build rough prototypes with AI coding tools and test their hunches in a browser. Some teams open draft pull requests clearly labeled as non-mergeable. Engineers may throw away every line and rebuild the feature properly. That’s fine. The prototype did its job the moment everyone could click the same thing and agree on how it should work.</p><p>Code also lets PMs answer their own questions. Point Cursor at a repository and ask how a user action travels from the interface through the API to the database. You can spot a legacy dependency before it eats half a planning meeting, and your engineer keeps an uninterrupted afternoon.</p><p>The serious practitioners add structure to catch what they’d miss. Meta PM Zevi Arnovitz runs a setup where Claude plays a virtual CTO, told to challenge bad assumptions, while models like Codex and Gemini review the output. Custom commands such as /create-plan and /peer-review keep the process honest and teach him engineering basics along the way.</p><p>Hiring managers have noticed. Product leaders at Laurel AI, Google AI, and DataRobot have added live vibe coding to PM interviews. Candidates share their screen and steer an agent from a rough idea to working code, against the clock.</p><h3>Ending the game of telephone in design</h3><p>Anyone who has watched a polished Figma file come back from development knows the feeling. The spacing drifts. The animation vanishes. The hover state turns up late, or never. Static artboards can’t fully capture responsive layouts, live data, or keyboard behavior, so details get lost.</p><p>Designers now skip part of that game of telephone. With v0, Lovable, Subframe, or Cursor, they generate real React and Tailwind components and judge them in the browser, where type, motion, and loading states behave as they will for users. Vercel CEO Guillermo Rauch has argued that designers should vibe code to protect product quality.</p><p>The Model Context Protocol and Figma Code Connect tighten the loop by linking AI editors to a company’s design system. The agent pulls approved tokens, spacing rules, and components, which saves designers from policing random shades of blue.</p><p>Some designers go further. They clone the frontend repo, adjust tokens, add animations, and submit pull requests to staging. Frontend developers get that time back for data and performance work. Companies now hire for this hybrid under a new title: Design Engineer.</p><h3>Marketers are building their way out of martech sprawl</h3><p>Marketers may have the most practical motive of all. Every new SaaS tool solves one problem and adds one invoice, while the gaps between tools stay stubbornly manual.</p><p><a href="https://newsletter.chiefmartec.com/p/vibe-coding-in-marketing-we-surveyed-300-marketing-leaders-on-its-adoption">Scott Brinker of chiefmartec and UserEvidence</a> surveyed 302 marketing leaders at software companies, all of whom already use AI coding tools. These are early adopters, so the numbers can’t tell you how common this is across marketing. They do show what happens once a team starts:</p><ul><li>57% build workflow automations such as lead routing and data syncs</li><li>50% build custom integrations between marketing platforms and databases</li><li>48% clean, enrich, or analyze data</li><li>52% used vibe coding in place of a no-code tool like Zapier or Make</li><li>49% used it in place of outside developers or agencies</li><li>46% used it in place of a dedicated SaaS product</li></ul><p>Most of this work happens backstage. Only 28% build landing pages or microsites, and 17% build customer-facing apps.</p><p>Who starts the effort matters too. Fast returns came to 47% of teams when marketers led the push, 30% when IT introduced it, and just 14% when a vendor pushed it. That tracks. The person who feels the pain knows exactly what “fixed” looks like. And 89% expect their use to grow over the next 12 months.</p><p>Some marketers also use Playwright and BeautifulSoup to track search results and GEO performance. A CLAUDE.md file holds their personas, past benchmarks, and brand voice.</p><h3>What “learning to code” means now</h3><p>The curriculum has changed shape. For this crowd, four skills do most of the heavy lifting:</p><ol><li><strong>Run the thing.</strong> Get comfortable with the terminal, install dependencies, keep secrets in a .env file, and use Git to branch, commit, and roll back.</li><li><strong>Break the work down.</strong> Agents flounder when you ask for a whole dashboard in one breath. They do far better with a short spec and one task at a time.</li><li><strong>Give the agent context.</strong> Files like CLAUDE.md or .cursorrules carry your conventions into every session, so you stop repeating yourself.</li><li><strong>Check the output.</strong> Read the diff, notice files the agent had no business touching, follow how the data changes, and test before you ship.</li></ol><p>That last skill is where fundamentals pay off. You can’t audit a contract written in a language you can’t read. Once you understand variables, functions, loops, and how data moves through a program, you can tell when an agent is confidently wrong. <a href="https://mimo.org/">Mimo</a> is a great way to build that literacy, with easy-to-follow lessons you can fit around a full-time job.</p><h3>The catch engineers keep pointing at</h3><p>Engineers have good reasons for skepticism, and anyone picking this up should hear them out.</p><p>Start with quality. <a href="https://www.coderabbit.ai/blog/state-of-ai-vs-human-code-generation-report">CodeRabbit analyzed 470 open source pull requests</a> and found 10.83 issues per AI-assisted PR, against 6.45 for human-only PRs. <a href="https://www.armorcode.com/blog/your-genai-code-debt-is-coming-due-heres-what-gartner-predicts">Gartner goes further</a>, predicting that prompt-to-app tools in the hands of citizen developers will raise software defects by 2,500% by 2028. Take any forecast with a pinch of salt, but the direction deserves attention.</p><p>Then comes ownership. When the app you shipped leaks customer data at 3 a.m., who gets the call? Usually an engineer who never saw the code until that moment. Bloated AI pull requests add to the load, because someone already stretched thin has to review them.</p><p>AI can also flatter beginners. An agent can take a prototype 90% of the way in an afternoon, and the remaining 10% (security, access controls, concurrency, compliance) can swallow most of the effort.</p><p>A few habits keep you out of trouble. Start with low-stakes internal tools. Keep customer data out until someone technical has reviewed your work. Label prototypes as prototypes. Talk to engineers early, too. In the Brinker survey, 83% of respondents work under a formal governance policy, and 53% turn mainly to IT or engineering colleagues for guidance.</p><h3>The people closest to the problem</h3><p>Writing syntax used to be the scarce skill. As agents take on more of it, the value moves to knowing the problem, having taste, and judging the result. Marketers, PMs, and designers already hold much of that. Code gives them a way to act on it.</p><p>Professional engineers stay essential, since someone has to own that hard final 10%. The line between “people who have ideas” and “people who build them” keeps getting blurrier, though, and that opens doors on both sides of it.</p><p>So the next time you catch yourself writing a ticket for a small script, try building a first version yourself. Worst case, you’ll write a much better ticket.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2743cf3e120a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Most People Quit Learning to Code in the First Month, and How to Avoid It]]></title>
            <link>https://medium.com/@srdan_82278/why-most-people-quit-learning-to-code-in-the-first-month-and-how-to-avoid-it-d0cf25978318?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/d0cf25978318</guid>
            <category><![CDATA[learn-coding]]></category>
            <category><![CDATA[learn-to-code]]></category>
            <category><![CDATA[coding-education]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[learn-to-program]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Tue, 27 Oct 2026 09:37:37 GMT</pubDate>
            <atom:updated>2026-10-27T09:37:37.674Z</atom:updated>
            <content:encoded><![CDATA[<p>Day one of learning to code feels amazing. You type a single line, hit run, and the screen greets you with “Hello, World!” For a second, you feel like a movie hacker.</p><p>Day nineteen is a different story. You’ve stared at the same error for two hours. Your coffee went cold somewhere around the second Google search. A quiet voice in your head asks whether you’re cut out for this at all.</p><p>If that sounds familiar, you have lots of company. Research on self-paced courses and coding apps suggests that 70% to 85% of independent learners quit within the first few weeks. Even university intro courses lose about a third of their students.</p><p>Those numbers point to a fixable problem: the way most people approach the first month. If you change the approach, the odds swing in your favor.</p><h3>The “coding gene” myth</h3><p>Plenty of quitters decide their brain can’t handle code. A 2006 paper called “The camel has two humps” fed this belief. Its authors claimed programming students split into two groups: those who get it and those who never will.</p><p>The authors later retracted that claim. Larger studies across many schools found no such split in grades. So what trips people up? Ordinary obstacles: mental overload, knowledge gaps that snowball, and expectations that clash with reality. You can fix every one.</p><h3>Reason 1: Your brain runs out of desk space</h3><p>Picture your working memory as a small desk. It holds three or four new things at once. Add a fifth, and something slides off the edge.</p><p>An experienced developer writes a loop on autopilot. A beginner juggles the syntax, the counter variable, the stop condition, the risk of going one step too far, and what changes on each pass. Five items on a four-item desk.</p><p>Now add a cryptic error message or a terminal that says “command not found.” Your patience usually goes first.</p><h3>Reason 2: Small gaps grow into big walls</h3><p>Programming concepts stack like Jenga blocks. Each new idea rests on the ones below.</p><p>Researcher Anthony Robins calls this Learning Edge Momentum. A shaky grasp of variables in week one makes conditions harder in week two. By week three, loops and functions arrive, and you wrestle three half-learned ideas at once.</p><p>The wall seems to appear overnight. The cracks formed weeks earlier.</p><h3>Reason 3: The honeymoon ends at a cliff</h3><p>Educator Erik Trautman mapped a pattern most self-taught coders know well. The first few weeks feel easy. Guided exercises hold your hand, someone else handles the setup, and every right answer earns a green checkmark. Confidence shoots up.</p><p>Then the training wheels come off. You open an empty file and try to build something on your own. Knowing the keywords suddenly means little. You have no idea where to start. Trautman calls this drop the Cliff of Confusion. He calls the bug-filled stretch after it the Desert of Despair. Most quitters leave right there.</p><h3>Reason 4: Computers don’t do “close enough”</h3><p>Human language forgives you. Mumble “me want coffee” at a barista, and you still get your latte. Forget one closing bracket, and the computer rejects the entire file.</p><p>You can spend four hours on a problem and make zero progress. Then you spot a single typo, fix it, and everything works.</p><p>Adults expect effort to pay off in steady steps. When it doesn’t, many read every error as a verdict on their intelligence. Treat errors like a smoke alarm over burnt toast. Annoying, sure, but useful. They point you to the problem.</p><h3>Reason 5: AI does the heavy lifting for you</h3><p>Chatbots make patient tutors. They also make tempting crutches. Paste a problem, copy the answer, move on. Feels productive.</p><p>The catch? The struggle you skipped builds the skill. Letting AI write your code is like sending a friend to the gym for you. Worse, AI sometimes writes broken or overly fancy code, and as a beginner, you can’t spot or fix the problem.</p><h3>How to make it past month one</h3><p>None of these problems needs a genius. A few habits do the job.</p><h3>Read code before you write it</h3><p>Kids read for years before anyone asks them to write an essay. Coding works the same way. Research suggests beginners need about 50% accuracy at tracing code in their head before they write reliable programs.</p><p>Researcher Sue Sentance built a method around this idea called PRIMM:</p><ul><li><strong>Predict</strong> what a piece of code will do before running it</li><li><strong>Run</strong> it and compare the result with your guess</li><li><strong>Investigate</strong> it line by line</li><li><strong>Modify</strong> it to do something new</li><li><strong>Make</strong> your own version from scratch</li></ul><p>Apply it to any snippet you find. Guess first, then check. Wrong guesses teach you the most.</p><h3>Practice logic before syntax</h3><p>Typos and missing brackets drain a beginner’s mental energy. Some exercises hand you the pieces of a program and ask you to put them in order. Educators call these Parsons problems. Studies show they teach as well as writing from scratch, in less time.</p><p>Look for lessons that let you fill in blanks, reorder lines, or tweak working code. Save the blank page for later.</p><h3>Skip the setup for now</h3><p>Installing compilers, fixing file paths, and fighting your terminal can eat whole days. Postpone all of it for two weeks.</p><p>Start somewhere that runs code with zero installation. Browser playgrounds work, and so do coding education platforms like <a href="https://mimo.org/">Mimo</a>, which let you write and run code in short lessons on your laptop. Once variables, conditions, and loops feel comfortable, set up a local editor. By then, setup feels like a minor chore.</p><h3>Debug out loud</h3><p>When code breaks, beginners often change lines at random and hope something sticks. Programmers call this shotgun debugging. It rarely works.</p><p>Try these instead:</p><ul><li><strong>Talk to a rubber duck.</strong> Explain each line out loud to an object on your desk. Talking slows you down, and the bug often jumps out mid-sentence.</li><li><strong>Trace on paper.</strong> Draw a small table and log each variable’s value on every pass of the loop. The paper holds the details so your brain doesn’t have to.</li><li><strong>Add print statements.</strong> Print values before and after the tricky part. Real data beats guessing every time.</li></ul><h3>Let AI explain while you write</h3><p>Set one simple rule: AI can explain, but you do the writing. Paste in an error message and ask, “What does this mean, and where should I look?” Skip prompts like “Write me a function that does X.”</p><p>You get unstuck faster and keep the learning.</p><h3>Pick a pace you can keep</h3><p>#100DaysOfCode motivates lots of people. It also burns out plenty. Miss one day for work or a sick kid, and the broken streak kills your drive.</p><p>A better setup has two parts:</p><ol><li>A small daily floor of 20 to 30 minutes</li><li>A weekly goal of four or five sessions, so one bad day doesn’t sink the week</li></ol><p>Short, regular sessions beat weekend marathons. Five hours on a Saturday tires out your brain long before the lessons sink in.</p><h3>Keep your first project tiny</h3><p>Everybody dreams of a multiplayer game or the next billion-dollar app. Resist. Limit your first project at about 100 lines of code.</p><p>A tip calculator, a number-guessing game, or a to-do list that runs in the terminal all fit the bill. Finishing something small gives you a real win. Abandoning something huge gives you one more reason to quit.</p><h3>A simple 30-day plan</h3><p>Here’s how your first month could look:</p><ul><li><strong>Week 1:</strong> Variables, data types, and if/else statements. Read and predict code more than you write it. Stay in the browser.</li><li><strong>Week 2:</strong> Loops and lists. Reorder scrambled code, fix small bugs, and trace every loop on paper.</li><li><strong>Week 3:</strong> Functions. Modify and extend existing programs. Install a simple code editor. Use AI only to explain errors.</li><li><strong>Week 4:</strong> Build one small project from start to finish, under 100 lines. Save your work with Git.</li></ul><p>You won’t be job-ready after 30 days, and you don’t need to be. Month one has a simpler goal: learn how code runs and get comfortable being stuck.</p><h3>The bottom line</h3><p>Most first-month quitters had the ability all along. They piled too much onto their mental desk, let small gaps grow, and took every error personally.</p><p>So start small. Read before you write. Hold off on the setup. Treat bugs as clues. Show up for 20 minutes, most days, and give your brain time to catch up.</p><p>Day nineteen will still come. This time, you’ll know what to do with it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d0cf25978318" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Should You Stop Taking Coding Courses and Start Building Projects?]]></title>
            <link>https://medium.com/@srdan_82278/when-should-you-stop-taking-coding-courses-and-start-building-projects-651d4b0cfefe?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/651d4b0cfefe</guid>
            <category><![CDATA[programming-course]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[coding-courses]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[career-advice]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 21:49:48 GMT</pubDate>
            <atom:updated>2026-10-12T21:49:48.459Z</atom:updated>
            <content:encoded><![CDATA[<p>I once watched a friend finish his fourth JavaScript course in six months. He had certificates, detailed notes, and a GitHub profile full of projects he had built alongside instructors. Then I asked him to make a simple tip calculator from scratch.</p><p>He opened a blank file, stared at it for a while, and eventually went back to YouTube. The problem wasn’t that he hadn’t studied enough, he had simply spent months learning in an environment where someone else made almost every important decision for him. The instructor chose the project, set up the files, picked the libraries, and showed him what to type next.</p><p>He had learned to recognize code. He hadn’t had enough practice deciding what code to write.</p><p>That’s a very common stage when you’re learning programming, and it’s usually a sign that you need less instruction and more time building things on your own.</p><h3>Why courses can feel more productive than they are</h3><p>Courses are useful because they remove uncertainty. You don’t have to decide what to build or where to begin. The lesson already has a goal, the project structure is prepared, and if something goes wrong, the instructor usually knows exactly where the problem is.</p><p>That makes learning feel smooth. You finish a lesson, the app works, and you move on with a clear sense that you’ve made progress.</p><p>The problem appears when that structure disappears. You may have already seen APIs, databases, async JavaScript, authentication, and state management several times, but recognizing those concepts inside someone else’s project is different from knowing when to use them yourself.</p><p>That creates a gap between exposure and ability. You’ve seen a lot, so you feel like you should be able to build a lot. Then you open an empty editor and realize you don’t know how to turn an idea into the first few steps.</p><p>A lot of people respond by assuming they need another course. Usually, they need the opposite.</p><h3>You don’t need to know the whole language first</h3><p>Beginners often wait too long before building something independently because they think they need to “finish” JavaScript, Python, or another language first. There isn’t really a finish line.</p><p>Professional developers look things up constantly. They forget syntax, check documentation, search for examples, and learn new libraries while working on a project. What they have is enough understanding of the fundamentals to start.</p><p>You’re probably ready to build small projects once you can work comfortably with variables, basic data types, conditions, loops, collections such as arrays or lists, and functions that take some input and produce a result. You should also be able to look at a basic error message and at least start investigating what went wrong.</p><p>That’s enough. You do not need to understand advanced architecture, every array method, or the entire language specification before opening a blank file.</p><p>If you’re still building those foundations, something structured like <a href="https://mimo.org/">Mimo</a> can help because the lessons are short and hands-on. But once the basics start feeling familiar, the next step should be using them without the lesson telling you what to do.</p><h3>How to know you’re ready to move on</h3><p>One of the clearest signs is that you’ve started debugging things without immediately going back to the instructor. At the beginning, every error feels mysterious. If something doesn’t work, you rewind the lesson and compare your code line by line.</p><p>Eventually, that changes. You read the error, search for the specific message, look at the documentation, try one thing, then another, and eventually work out what happened. That matters because debugging is part of programming, not something that interrupts programming.</p><p>Another sign is boredom. If you keep guessing what the instructor is about to type, skipping ahead, or thinking of ways you’d change the project, you’re probably ready to stop following along so closely.</p><p>And if you’ve bought three different courses covering basically the same topic, that’s another clue. At some point, another React course is not going to teach you what building a React app will.</p><h3>Learn things when the project gives you a reason to care</h3><p>Traditional education often teaches things in advance because they may become useful later. Programming works surprisingly well the other way around.</p><p>You start building something with what you already know. Eventually, you run into a problem you can’t solve. Then you learn the concept that solves that problem and keep going.</p><p>That context makes the new idea much easier to remember.</p><p>Imagine you’re building a simple recipe app. At first, your recipes live inside an array in the code, and that’s fine. Then you refresh the page and realize any recipes the user added disappear, so now you have a reason to learn about local storage.</p><p>Later, you decide you want someone else to be able to log in and see those recipes from another device. Suddenly local storage isn’t enough anymore, so databases and authentication start making sense.</p><p>You aren’t learning databases because a curriculum says “Week 7: Databases.” You’re learning them because your project reached a point where you need one. That difference matters because the concept now has a problem attached to it, and that makes it much easier to remember.</p><h3>Don’t jump straight from tutorials into a huge app</h3><p>There’s no need to close every course forever and immediately try to build the next Airbnb. That usually creates a different kind of frustration.</p><p>A better transition is to start with something you’ve already built. Take one of your course projects, close the lesson, and change it.</p><p>If you built a to-do list, add priorities. Add search. Make overdue tasks behave differently. Save the data between sessions. Add categories or change the way the state is structured.</p><p>The original project gives you enough of a foundation that you’re not staring at a completely empty screen, but the new features force you to make your own decisions. That’s a good bridge between guided learning and independent work.</p><h3>Break projects into smaller problems</h3><p>One of the biggest differences between beginners and more experienced developers is not that experienced developers can instantly see the whole solution. They’re usually better at breaking the problem down.</p><p>“Build a chess game” is overwhelming. “Display an 8x8 board” is manageable.</p><p>Then you can place the pieces. After that, make one piece move. Then check whether that move is legal. Then handle turns. The project gets built one small problem at a time.</p><p>The same idea works for almost anything. Instead of asking, “How do I build a booking system?” ask, “How do I display available dates?” Then, “How do I store a selected date?” Then, “How do I prevent someone from choosing a date that has already been booked?”</p><p>If a task still feels vague or intimidating, make it smaller again.</p><h3>Make each project slightly harder than the last</h3><p>You don’t need every project to be dramatically more ambitious than the previous one. A gradual increase in difficulty works much better.</p><p>You might begin with something that is mostly logic, such as a small command-line budget tracker or guessing game. Then build an interactive webpage using plain JavaScript, where user actions change what appears on the screen.</p><p>After that, build something that saves data through a backend and database. Then introduce an external API and deal with what happens when that service is slow, unavailable, or returns unexpected information. Eventually, you can move into multi-user applications with authentication, permissions, and a live deployment.</p><p>Each project gives you problems that prepare you for the next one. That progression is much more useful than repeatedly building the same level of project with a different design.</p><h3>Don’t rush into frameworks just because everyone uses them</h3><p>React, Next.js, and other frameworks are useful, but it’s worth spending some time building with plain JavaScript first. You do not need to become a vanilla JavaScript purist. You just want enough experience to understand the problems frameworks are solving.</p><p>Handle click events yourself. Update the DOM. Keep track of application data. Build a couple of interfaces where state starts becoming annoying to manage.</p><p>Then, when you learn React, concepts such as components and state management have a reason to exist. If you jump straight into a framework, it’s easy to end up memorizing patterns without understanding which parts come from JavaScript and which parts come from the framework.</p><p>That makes debugging much harder later.</p><h3>AI can create the same problem in a different way</h3><p>There’s now another version of tutorial dependence. You describe what you want to an AI coding tool, it generates the code, and the application starts working.</p><p>That can feel much more productive than watching a course, but if you can’t explain the code or change it without asking the AI again, you haven’t really escaped the original problem. Someone else is still making the decisions for you.</p><p>AI can absolutely help you learn. The way you use it matters.</p><p>If you’re stuck, ask it to explain an error instead of immediately asking for the completed solution. Ask it to point you toward the part of your code that deserves attention, or explain why one approach works better than another. Then make the change yourself.</p><p>And if AI gives you code, make sure you understand what it does before adding it to the project. A useful test is simple: if you had to explain that code in an interview tomorrow, could you?</p><p>If the answer is no, spend more time with it.</p><h3>Independent projects will feel slower</h3><p>This is the part that catches people off guard. Building on your own often feels like you’re learning less because progress becomes much slower.</p><p>In a course, you might finish three lessons in an hour. On your own, you might spend that same hour trying to understand why a form won’t submit.</p><p>It feels worse, but it can be much more valuable.</p><p>That hour teaches you how to inspect what’s happening, form a theory, test it, realize you were wrong, and try again. That process is difficult to package neatly into a course because the confusion is part of the learning.</p><p>You’ll still have days where the problem turns out to be something embarrassingly small. That’s normal. The important part is that you found it.</p><h3>You don’t have to stop taking courses completely</h3><p>The goal isn’t to decide that courses are bad. They’re useful when you genuinely need structure around a new topic.</p><p>The difference is that they should gradually become supporting material instead of the main place where you write code.</p><p>Maybe you’re building a project and realize you don’t understand authentication. Take a focused lesson on authentication, then go back to the project and use it. Later, you need testing, so learn enough testing to solve the problem you have.</p><p>That’s a much healthier relationship with courses than moving from one complete beginner program straight into another.</p><h3>So, when should you start building on your own?</h3><p>Earlier than you probably think.</p><p>Once you know the core syntax and can work through small problems without someone showing you every line, pick a project. Keep it small enough that you can finish it, but open-ended enough that you’ll have to make some decisions yourself.</p><p>Expect to look things up, get stuck, and make a messy first version. None of that means you started too early. That’s the part of learning that was missing when everything happened inside a course.</p><p>Courses are good at introducing you to the tools. Projects teach you what to do when nobody tells you which tool to pick.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=651d4b0cfefe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python vs. SQL: Which Is Better for Beginners in Data Analysis?]]></title>
            <link>https://medium.com/@srdan_82278/python-vs-sql-which-is-better-for-beginners-in-data-analysis-9e9ae3b0b96b?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e9ae3b0b96b</guid>
            <category><![CDATA[data-analysis]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[python-data-analysis]]></category>
            <category><![CDATA[sql-data-analysis]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Mon, 12 Oct 2026 21:08:28 GMT</pubDate>
            <atom:updated>2026-10-12T21:08:28.714Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’re moving into data analysis, one of the first questions you’ll probably run into is whether to learn SQL or Python first.</p><p>Both are important and both show up in analyst roles. And if you search for advice, you’ll find plenty of people arguing strongly for one or the other.</p><p>For most beginners, though, SQL is the better place to start.</p><p>It gets you closer to the type of work analysts actually do day to day, and it teaches you how to work with structured data before you add the extra complexity of a general-purpose programming language.</p><p>Python becomes very useful later. You just don’t need to start there.</p><h3>SQL and Python solve different problems</h3><p>SQL and Python feel different because they ask you to think in different ways.</p><p>With SQL, you describe the result you want from the data and let the database work out how to retrieve it. You might ask for total sales by region, customers who haven’t ordered in six months, or the top-performing products in each category.</p><p>A query might look like this:</p><pre>SELECT region, SUM(amount) AS total_sales<br>FROM orders<br>WHERE order_date &gt;= &#39;2026-03-01&#39; AND order_date &lt; &#39;2026-04-01&#39;<br>GROUP BY region;</pre><p>Even if you’ve never written SQL before, you can probably get a rough idea of what that query is doing.</p><p>Python gives you much more freedom. You can load files, transform data, automate tasks, build statistical models, scrape websites, create applications, and do far more than SQL was designed for.</p><p>That flexibility comes with more overhead.</p><p>You’re not only learning how to analyze data. You’re also learning programming concepts such as variables, loops, functions, objects, packages, and environments.</p><p>For someone whose immediate goal is to become a data analyst, SQL usually gets you to useful work faster.</p><h3>Most company data already lives somewhere SQL can reach</h3><p>Another reason to start with SQL is where the data actually lives.</p><p>Businesses usually keep important information in databases and data warehouses. Customer records, payments, orders, product activity, marketing events, and operational data often sit in systems such as PostgreSQL, BigQuery, Snowflake, or similar platforms.</p><p>SQL lets you work with that data where it already lives.</p><p>That matters when the datasets become large. If you only need sales from one region for the last three months, it makes more sense to let the database filter millions of rows first and return a much smaller result than to pull the entire table onto your laptop and sort it out afterwards.</p><p>In practice, SQL and Python often work together.</p><p>SQL does the heavy filtering, joining, and aggregation inside the database. Python then takes the cleaner result and handles whatever comes next, whether that’s deeper analysis, automation, visualization, or modeling.</p><p>That’s why learning SQL first creates such a useful foundation.</p><h3>SQL is usually the more important first skill for analyst jobs</h3><p>For many entry-level data analyst and BI roles, SQL is one of the first technical skills employers look for.</p><p>Python appears often too, but it isn’t always essential for junior positions. Plenty of analysts spend most of their day working with SQL, spreadsheets, and a BI tool such as Power BI or Tableau.</p><p>It’s much harder to work as a data analyst without being comfortable querying data.</p><p>The interview process often reflects that. SQL may appear early in a technical screen, where you’re asked to solve problems involving joins, aggregation, dates, rankings, or customer activity.</p><p>You might need to work out someone’s first order, compare revenue from one month with the previous month, rank products within a category, or identify a particular user cohort.</p><p>Python is more likely to matter once the role involves heavier analysis, automation, forecasting, or data science.</p><p>So if your immediate goal is getting ready for an entry-level analyst role, SQL gives you the more useful starting point.</p><h3>SQL looks simple at first, but the logic takes practice</h3><p>One reason beginners underestimate SQL is that the syntax looks fairly approachable.</p><p>You can learn what SELECT, FROM, WHERE, and GROUP BY do relatively quickly.</p><p>The harder part is understanding how queries behave once several operations are happening at the same time.</p><p>If you come from spreadsheets, you may be used to thinking about individual cells and rows. SQL asks you to think about whole sets of records.</p><p>Joins are a good example.</p><p>Joining two tables sounds simple until you use the wrong key and suddenly your result contains far more rows than either table started with. Or you use an inner join and accidentally remove customers who don’t have a matching record in the second table.</p><p>The query still runs.</p><p>The answer is simply wrong.</p><p>That’s where SQL starts becoming less about memorizing commands and more about understanding the structure of your data.</p><p>Common Table Expressions and window functions take more practice too, but they’re worth learning because they show up constantly in analytics work. Once you’re comfortable with them, questions such as ranking users, calculating running totals, or comparing one period with another become much easier to handle.</p><h3>Python has a different kind of learning curve</h3><p>Python is considered beginner-friendly for a programming language, but there’s still more to learn before you reach the analysis itself.</p><p>You need to understand basic programming concepts such as variables, lists, dictionaries, loops, functions, and conditions.</p><p>Then there’s the setup.</p><p>You may need to install Python, choose an editor, create a virtual environment, manage packages, and work out why something behaves differently on your computer than it did in the tutorial.</p><p>After that comes pandas, which introduces its own way of working with data.</p><p>None of this is a reason to avoid Python. It just means you’re learning several things at once.</p><p>If you’re completely new to both programming and data analysis, SQL lets you focus first on the data questions themselves.</p><p>Python makes more sense once that foundation is already there.</p><h3>Where Python becomes especially useful</h3><p>There are plenty of situations where SQL alone won’t be enough.</p><p>Maybe you want to build a model that predicts which customers are likely to churn. Perhaps you need to analyze thousands of customer reviews, collect data from a website, or automate a report that your team currently rebuilds manually every Monday.</p><p>Libraries such as pandas help with data manipulation, while scikit-learn and statsmodels open the door to modeling and statistical analysis. Other libraries can help with web scraping, automation, visualization, and many other tasks.</p><p>The important thing is that Python often works with data you’ve already retrieved and prepared using SQL.</p><p>That’s why the two skills complement each other so well.</p><p>SQL gets the right data out.</p><p>Python gives you more ways to work with it.</p><h3>A practical order for learning data analysis</h3><p>You don’t need to learn every analytics tool at the same time.</p><p>A smoother path is to add them in stages.</p><p>If spreadsheets are new to you, start there. Learn how tables work, get comfortable with formulas and lookups, and practise using pivot tables to summarize information.</p><p>Then move into SQL.</p><p>Spend enough time on it that joins, aggregation, subqueries, Common Table Expressions, and window functions stop feeling unusual. Don’t rush through the basics just because the syntax seems easy.</p><p>After that, learn a BI tool such as Power BI or Tableau.</p><p>At this point, you can already do a lot of the work expected in entry-level analyst roles: retrieve data, clean and summarize it, and turn the results into something people can understand.</p><p>Then add Python.</p><p>By the time you get there, many of the ideas will already feel familiar. A pandas .merge() is conceptually similar to a SQL join. A .groupby() is doing something you’ve already seen with GROUP BY.</p><p>You’re learning a new tool, but not a completely new way of thinking about data.</p><p>If you want structured practice, Mimo has both a <a href="https://mimo.org/courses/learn-sql">SQL course</a> and a <a href="https://mimo.org/courses/learn-python">Python course</a>. The short, interactive format can work well if you want to build consistency without sitting through long lessons.</p><p>Once you’re comfortable with both, tools such as DuckDB can also be useful because they let you use SQL directly on files such as CSVs while working in a Python environment. It’s a nice bridge between the two.</p><h3>Should you learn SQL and Python at the same time?</h3><p>You can, but there usually isn’t much benefit to rushing both.</p><p>If you’re new to programming, you’re already learning a new way of thinking. Trying to understand SQL joins while also learning Python loops, environments, and pandas can make the whole process feel harder than it needs to be.</p><p>Give yourself time to become comfortable with one first.</p><p>SQL is a good choice because you can start answering real data questions fairly quickly. Once joins, grouping, filtering, and window functions feel familiar, bring Python into the mix.</p><p>There will obviously be some overlap while you learn. You don’t have to finish every possible SQL topic before touching Python.</p><p>The point is simply to avoid dividing your attention between two completely new tools from the first day.</p><h3>AI can help, but you still need to practice without it</h3><p>AI assistants are useful when you’re learning either language.</p><p>They can explain an error, show you another way to structure a query, or help you understand why your pandas code isn’t returning what you expected.</p><p>Use that help.</p><p>Just don’t let it replace your own practice.</p><p>If you’re interviewing for an analyst role, you may still need to write or explain SQL yourself. More importantly, once you’re working with real company data, you need enough understanding to know whether an AI-generated query is actually correct.</p><p>A query can run successfully and still join the wrong tables, duplicate records, or calculate a metric at the wrong level.</p><p>You need to be able to spot that.</p><h3>So, should you learn SQL or Python first?</h3><p>For most people aiming at data analysis, start with SQL.</p><p>It gets you working with real business data faster, it appears across a huge range of analyst roles, and it teaches you the relational thinking that makes many later tools easier to understand.</p><p>Once you’re comfortable querying, joining, grouping, and analyzing data with SQL, add Python.</p><p>That’s when Python becomes much more useful. You can automate repetitive work, handle more complicated transformations, run statistical analysis, and start exploring areas such as forecasting and machine learning.</p><p>You’ll probably need both eventually, just not on day one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e9ae3b0b96b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Think in React Instead of Just Memorizing Syntax]]></title>
            <link>https://medium.com/@srdan_82278/how-to-think-in-react-instead-of-just-memorizing-syntax-a7bb3b783493?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/a7bb3b783493</guid>
            <category><![CDATA[react-programming]]></category>
            <category><![CDATA[react-for-beginner]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[learn-react-js]]></category>
            <category><![CDATA[reactjs]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Mon, 28 Sep 2026 07:59:43 GMT</pubDate>
            <atom:updated>2026-09-28T07:59:43.464Z</atom:updated>
            <content:encoded><![CDATA[<p>My first React project had a sticky note on the monitor. It listed the useEffect dependency rules, the Context provider setup, and a reminder that useCallback “does something with functions.” I could recite all of it. I still couldn’t figure out why my search page re-rendered four times every time I typed a letter.</p><p>My problem sat deeper than syntax. I was writing React like jQuery with extra steps, and no amount of memorization could fix that.</p><h3>Stop telling the DOM what to do</h3><p>In vanilla JavaScript, you give orders. Find this element. Add this class. Append that list item. Remove the spinner. The DOM holds your truth, and you keep it in sync by hand.</p><p>This approach holds up for a to-do app. Past that, every new feature adds more wires between elements. One missed update and the counter says 3 while the list shows 4.</p><p>React changes this. You describe what the screen should look like for a given set of data, and React figures out the DOM changes. The whole idea fits in one line:</p><p><strong>UI = f(state)</strong></p><p>Think of a spreadsheet. Some cells hold raw numbers. Others hold formulas like =SUM(A1:A10). Change a number and the formula cells update on their own. You never write instructions to erase the old total and type a new one.</p><p>In React, state is the raw cell. Your component is the formula. The rendered page is the grid you see.</p><h3>Plan the component tree before you type</h3><p>The React docs describe a process called “Thinking in React.” I ignored it for months because it looked like beginner material. Big mistake. The short version goes like this:</p><ol><li><strong>Break the UI into components.</strong> Draw boxes around parts of the design. Each box should do one job. If your data comes as JSON, the boxes often match its shape.</li><li><strong>Build a static version first.</strong> Render everything from hardcoded props. No state, no clicks. This part takes lots of typing and little thinking.</li><li><strong>Find the minimal state.</strong> For every value, ask three questions. Does it stay the same over time? Then it’s not state. Does it come from a parent as a prop? Not state. Can you calculate it from other state or props? Definitely not state.</li><li><strong>Decide where state lives.</strong> Find every component that uses a value. Put the state in their closest shared parent.</li><li><strong>Add inverse data flow.</strong> Children can’t change a parent’s state directly. So the parent passes down a callback, and the child calls it.</li></ol><p>Step two is the one people skip. Separating layout from interactivity means you debug one kind of problem at a time. Layout problems are easy. State problems are hard.</p><h3>Store less state than you think</h3><p>I wrote this pattern dozens of times before anyone told me it was wrong:</p><pre>const [items, setItems] = useState([]);<br>const [query, setQuery] = useState(&#39;&#39;);<br>const [filtered, setFiltered] = useState([]);<br><br>useEffect(() =&gt; {<br>  setFiltered(items.filter(i =&gt; i.name.includes(query)));<br>}, [items, query]);</pre><p>Looks tidy. Performs badly. React renders with the old filtered list, paints it, then runs the effect, sets new state, and renders again. The user sees a flash of stale data.</p><p>The fix is very simple:</p><pre>const filtered = items.filter(i =&gt; i.name.includes(query));</pre><p>This works like a formula cell. It recalculates during render, with no second pass. If the list is huge and filtering is slow, wrap it in useMemo. Still no effect needed.</p><p>The same logic applies to resets. Say you have a profile editor and the user switches from Ana to Marko. Skip the effect that clears every field and give the component a key:</p><pre>&lt;ProfileEditor key={user.id} user={user} /&gt;</pre><p>A new key tells React this is a different component. React throws away the old state and starts fresh. No cleanup code.</p><h3>Every render is a photograph</h3><p>If you learned React through class components, you probably think in lifecycles: mount, update, unmount. That model will mislead you in function components.</p><p>A function component doesn’t live on and change over time. React calls it again on every render, and each call produces a snapshot. Inside that snapshot, state and props are constants. They don’t update under your feet.</p><p>This explains the classic “stale value” bug:</p><pre>function Counter() {<br>  const [count, setCount] = useState(0);<br><br>  function handleClick() {<br>    setCount(count + 1);<br>    setTimeout(() =&gt; alert(count), 3000);<br>  }<br>  // ...<br>}</pre><p>Click once. The alert shows 0. The timeout closed over the snapshot where count was 0. React worked exactly as designed. You were looking at an old photo.</p><p>Once you accept this, closures stop feeling like traps.</p><h3>Save useEffect for the outside world</h3><p>Before every useEffect, I now ask one question: what external system am I syncing with?</p><p>Valid answers include a WebSocket, a browser API like IntersectionObserver, a chart library that doesn’t speak React, or a manual DOM measurement. If my answer is “my own state,” I’ve probably put the logic in the wrong place.</p><p>A quick sorting guide:</p><ul><li><strong>Something the user did</strong> (click, submit, drag): put it in the event handler.</li><li><strong>Data you need to reshape</strong>: calculate it during render (see above).</li><li><strong>A full reset when the subject changes</strong>: use a key (see above).</li><li><strong>Something outside React</strong> (sockets, timers, third-party widgets): use an effect with a cleanup function.</li></ul><p>Event handlers know why something happened. Effects only see that some data changed. That context matters. If a form submission should send an analytics event, the submit handler knows the user clicked “Buy.” An effect watching order has no idea.</p><h3>Make bad states impossible</h3><p>Look at this and spot the bug:</p><pre>const [isLoading, setIsLoading] = useState(false);<br>const [isError, setIsError] = useState(false);<br>const [isSuccess, setIsSuccess] = useState(false);</pre><p>Three booleans give you eight combinations. Maybe four make sense. The others, like loading and error at the same time, will show up eventually. Usually during a demo.</p><p>Use one value instead:</p><pre>type Status = &#39;idle&#39; | &#39;loading&#39; | &#39;success&#39; | &#39;error&#39;;<br>const [status, setStatus] = useState&lt;Status&gt;(&#39;idle&#39;);</pre><p>Now your data can only be in one state at a time. Your render logic shrinks to a simple switch on one value. For multi-step forms or flows with lots of transitions, move the logic into useReducer, or reach for a state machine library like XState.</p><h3>Fix performance with structure first</h3><p>When an app feels slow, the first instinct is to sprinkle useMemo, useCallback, and React.memo everywhere. I’ve done it. The code got harder to read and the numbers barely moved. Dependency comparisons have a cost too.</p><p>Two structural fixes usually work better.</p><p><strong>Move state down.</strong> This is the rule from step 4 again: keep state as low as it can go. When state lives high in the tree, every change re-renders everything below it. If only a search box needs the query, keep the query in the search box.</p><p><strong>Pass expensive parts as children.</strong></p><pre>function ScrollTracker({ children }) {<br>  const [scrollY, setScrollY] = useState(0);<br>  return (<br>    &lt;div onScroll={e =&gt; setScrollY(e.currentTarget.scrollTop)}&gt;<br>      &lt;HeaderIndicator offset={scrollY} /&gt;<br>      {children}<br>    &lt;/div&gt;<br>  );<br>}<br><br>&lt;ScrollTracker&gt;<br>  &lt;ExpensiveDashboard /&gt;<br>&lt;/ScrollTracker&gt;</pre><p>The parent creates ExpensiveDashboard outside ScrollTracker. When scroll state changes, ScrollTracker re-renders, but the children prop holds the same element as before. React skips the dashboard. No memo hooks required.</p><p>The React Compiler now handles a lot of memoization for you at build time. That doesn’t let you off the hook, pun intended. The compiler expects pure components, no mutation, and effects used properly. Messy code stays messy with or without it.</p><h3>Two exercises that build the instinct</h3><p>Reading about mental models only gets you so far. These two habits did more for me than any tutorial.</p><p><strong>Plan on paper.</strong> Print a screenshot of an app you use and grab two highlighters. Use one color for components and the other for where each piece of state lives. Do this before writing any code. You’ll catch structural mistakes that would otherwise eat an afternoon.</p><p>If you’re working through a structured course like <a href="https://mimo.org/courses/learn-react">Mimo’s React course</a>, try this at the start of each lesson project, then compare your sketch with the finished code.</p><p><strong>Run a zero-effect audit.</strong> Open an existing project and run every useEffect through the sorting guide above. Whatever doesn’t talk to something outside React goes. Most projects lose more than half their effects. Effects that fetch data are valid, but a library like TanStack Query handles them better.</p><h3>Syntax follows understanding</h3><p>Nobody I respect in React has every hook signature memorized. They look things up all the time. What they carry around is a clear picture of how data moves through a component tree.</p><p>That picture comes down to four ideas:</p><ul><li>The UI is a snapshot of state, recalculated each render.</li><li>State should be minimal. Everything else gets calculated.</li><li>Effects sync with the outside world. Everything else belongs in handlers or render.</li><li>Good structure beats scattered memoization.</li></ul><p>Get those right and the syntax stops feeling like a list to memorize. You’ll know you need a key or a callback because the design tells you so. Throw away the sticky note. You won’t miss it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a7bb3b783493" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Skills Do Python Developers Need Besides Python?]]></title>
            <link>https://medium.com/@srdan_82278/what-skills-do-python-developers-need-besides-python-67aebad3bec4?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/67aebad3bec4</guid>
            <category><![CDATA[python]]></category>
            <category><![CDATA[python-development]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[python-developers]]></category>
            <category><![CDATA[career-advice]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Wed, 09 Sep 2026 15:09:14 GMT</pubDate>
            <atom:updated>2026-09-09T15:09:14.185Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>You can learn Python syntax in a weekend. Loops, list comprehensions, decorators, a few clever one-liners to impress your friends. And then you land a real job, open a production codebase, and realize the language was the easy part.</blockquote><p>In serious software systems, Python rarely does the heavy lifting alone. It sits on top of operating systems, databases, network sockets, and compiled C extensions. Its job is to glue them together. Python is the conductor, not the orchestra. Your real value as a developer comes from everything happening around the code you write.</p><p>The skills below are what turn Python knowledge into working software.</p><h3>Git, and Not Just the Three Commands Everyone Memorizes</h3><p>Most beginners learn add, commit, push, and call it a day. That gets you through solo projects. It falls apart the moment you join a team.</p><p>Real collaboration runs on version control, and the mechanics get deep fast. Interactive rebasing. Merge conflicts to resolve at 4pm on a Friday. Branching strategies that keep a project history clean enough to actually debug. When a bug reaches production, a well-kept commit history lets you bisect your way to the exact change that broke things. A messy one leaves you guessing.</p><p>Platforms like <a href="https://github.com/">GitHub</a> and <a href="https://about.gitlab.com/">GitLab</a> aren’t just storage lockers for code either. Pull requests become checkpoints. Automated linting, tests, and static analysis decide whether your work gets through the gate. Learn to work <em>with</em> that system, not around it.</p><h3>Testing Saves You From Yourself</h3><p>Manually poking at your code in the REPL feels productive. That approach collapses the second your codebase grows past a few hundred lines, and it collapses quietly, which is worse. You change one function, three unrelated things break, and you find out days later in production.</p><p>Automated tests fix this. Written well, they double as executable specifications. If you’re learning Python today, pytest is the tool worth your time. The community settled on it years ago. The draw is its clean assertion syntax, its fixture system, and a plugin ecosystem that covers nearly everything.</p><p>You’ll also want to understand test doubles: mocks and fakes that isolate a piece of code from the messy outside world. Nobody wants a test suite that fails because a live API had a bad day. Tools like unittest.mock and pytest-mock let you swap out file systems, HTTP calls, and network boundaries. Your tests then run fast and give the same answer every time.</p><p>Testing against a real, throwaway database spun up in a container beats a fake in-memory stand-in almost every time. Query behavior, constraints, and transaction rollbacks act differently under live conditions. That gap is exactly where bugs hide.</p><h3>Speaking Fluent Database</h3><p>If I could hand one skill to every junior developer, it might be SQL. The returns on it are absurd relative to the effort.</p><p>Too many applications drag millions of rows across the network into Python memory just to loop over them. That’s slow, wasteful, and often unnecessary. Whenever the database can do the work, let it. Learn to write real queries. Learn what an index actually does. Learn to read an EXPLAIN ANALYZE output. It shows you the moment your database gives up and scans an entire table row by row.</p><p>ORMs like <a href="https://www.sqlalchemy.org/">SQLAlchemy</a> and <a href="https://www.djangoproject.com/">Django</a>’s ORM are wonderful productivity tools, and they’re exactly why this matters. The N+1 query problem is the classic trap. You fetch a list of items, and the ORM quietly fires off one extra query per item to load its related data. Ten items, eleven queries. Ten thousand items, and your page times out. The abstraction hid the SQL, so you never saw it coming. Understanding what runs underneath is what lets you catch it.</p><p>Then there’s schema migration. Tools like Alembic can auto-generate migration files, but treat those as rough drafts, not finished work. Auto-generators regularly mistake a column rename for a “drop the old one, create a new one” operation. That would delete your data. Read every migration before it runs.</p><p>Beyond the relational world, get comfortable with Redis for caching and session state. Learn when a document store like MongoDB fits better than forcing everything into tables. Different jobs, different tools.</p><h3>The Command Line Is Not Optional</h3><p>I’ve watched talented developers freeze the moment they leave their IDE. That’s a real vulnerability, because Python apps live on Linux servers, and Linux servers speak Bash.</p><p>You don’t need to be a shell wizard. You do need to move around a filesystem with confidence, check what’s eating your CPU with htop, manage file permissions, pipe commands together, and write small automation scripts. This is the difference between fixing a broken server yourself and filing a ticket to wait on someone else.</p><p>Networking counts too. Learn the basics of TCP/IP, DNS, HTTP status codes, and what a reverse proxy like Nginx does. It will save you during those brutal 2am debugging sessions when requests time out and nobody knows why. If you’ve built a solid Python foundation through something like <a href="https://mimo.org/courses/learn-python">Mimo’s Python course</a>, this systems layer is the natural next frontier.</p><h3>Docker, and the Alpine Trap</h3><p>Containers keep your app behaving the same on your laptop, in CI, and in production. Docker is basically table stakes now.</p><p>A classic beginner mistake is reaching for Alpine Linux because the base image is tiny. Alpine uses a different C library, musl instead of glibc. Most precompiled Python packages, NumPy and cryptography among them, are built assuming glibc. On Alpine, pip can&#39;t use those prebuilt wheels. It has to compile them from source. Your build now takes ten minutes, your image balloons in size, and that &quot;tiny&quot; advantage evaporates.</p><p>A Debian-based slim image like python:3.x-slim avoids all of it. Fast builds, fewer surprises, no mysterious musl bugs.</p><h3>Tooling That Finally Got Its Act Together</h3><p>Python tooling used to be a fragmented mess. A dozen tools for linting, formatting, and managing environments, none of them talking to each other. A newer generation has consolidated all of that, and it’s worth learning.</p><p>Both of the standouts happen to be written in Rust, and both are fast enough to change how the work feels. uv has taken over dependency management and virtual environments. It runs far faster than pip and poetry, and it handles lockfiles and even Python installation itself. For linting and formatting, ruff replaces a whole stack of older tools (flake8, black, isort) with a single binary. It finishes before you&#39;ve lifted your finger off the keyboard. Both are becoming the default, and both are a pleasure to use. Pick them up early.</p><h3>Choose Your Corner of the Map</h3><p>Nobody masters every domain, and you don’t need to. At some point you’ll drift toward one, and each has its own toolkit worth knowing:</p><p><strong>Web backends.</strong> Django still shines for full-stack apps with an admin panel baked in. For modern async APIs, FastAPI and Litestar dominate, paired with Pydantic for strict data validation. The catch with async is that one slow, CPU-heavy call can freeze your whole event loop. You’ll need to know which of your operations actually block (more on that below).</p><p><strong>Data engineering.</strong> Pulling everything into Pandas works until your data outgrows your RAM. Polars, built on the Arrow memory format, handles huge datasets with lazy evaluation and multithreading. DuckDB runs SQL directly against Parquet and CSV files without a database server. Both are worth having in your toolkit.</p><p><strong>Web scraping.</strong> Rendering whole pages with Selenium is the brute-force route. Often you can open the browser’s network tab, find the JSON API already feeding the page, and call it directly with a lightweight client like httpx. Cleaner data, a fraction of the resources.</p><p><strong>Applied AI.</strong> Heavy frameworks like LangChain make prototyping quick but production painful. Lean, typed setups hold up better under real traffic. Build them on official provider SDKs, and use Pydantic to validate the output. For semantic search, the pgvector extension lets PostgreSQL store embeddings next to your relational data. That means you skip running a separate vector database. One source of truth.</p><h3>Knowing What’s Under the Hood</h3><p>You don’t need to memorize CPython internals, but a few concepts pay off forever.</p><p>Memory in CPython runs on reference counting plus a garbage collector that cleans up circular references. And then there’s the Global Interpreter Lock, the famous GIL, which stops multiple threads from running Python code at the exact same time.</p><p>This one concept explains the async question from earlier. When your code waits on a network call or a database query, it’s I/O-bound. The GIL releases during the wait, so threading and asyncio let other work proceed. When your code crunches numbers, resizes images, or hashes data, it&#39;s CPU-bound. The GIL stays locked, and threads just take turns going nowhere. That work needs multiprocessing or a compiled extension. Knowing which camp an operation falls into keeps a slow function from freezing your whole server.</p><p>When something gets slow, don’t guess. Reach for a profiler. py-spy samples a running program and draws you a flame graph without touching your code. It&#39;s safe enough to use on live services. For memory leaks, Memray traces allocations all the way down into C extensions.</p><p>And when pure Python simply can’t go fast enough, compiled languages pick up the slack. The same Rust behind your new tooling can power your own code too. PyO3 lets you write safe, fast extensions that compile straight into native Python wheels, with none of the memory footguns of C.</p><h3>The Skills That Aren’t Technical at All</h3><p>Your career won’t stall on a hard algorithm. It’ll stall on communication.</p><p>Breaking a vague business request into clean components and clear API boundaries is a skill. So is explaining a technical trade-off to a product manager without their eyes glazing over. So is writing documentation your teammates can follow during an incident. And asking a clarifying question early, instead of building the wrong thing for two weeks, might be the most valuable skill of all.</p><p>Good engineers remember that code is a liability to maintain, not a trophy to collect. The goal isn’t more code. It’s a working solution built as simply as the problem allows.</p><h3>Where to Go From Here</h3><p>Python opens the door. Everything past it, the databases, the servers, the tests, the profilers, the conversations with your teammates, is what turns you into an engineer people trust with real systems.</p><p>This list can feel like a mountain. It isn’t, because the skills overlap more than they look. Reading a query plan builds the same cost-awareness that helps you profile Python. Writing good tests forces the clear module boundaries that make code easier to document and deploy. Progress in one area lowers the barrier to the next.</p><p>So start small. Get comfortable in the terminal this week. Write a real test suite for your next project. Read one EXPLAIN ANALYZE output and figure out what it&#39;s telling you. Do that for a while, and one day you&#39;ll look back at that weekend you spent learning syntax and smile at how far you’ve come.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67aebad3bec4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Become a Web Developer With No Experience?]]></title>
            <link>https://medium.com/@srdan_82278/how-to-become-a-web-developer-with-no-experience-792ea563d1e1?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/792ea563d1e1</guid>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[web-developer]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[career-change]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Thu, 03 Sep 2026 19:35:31 GMT</pubDate>
            <atom:updated>2026-09-03T19:35:31.070Z</atom:updated>
            <content:encoded><![CDATA[<p>Getting into web development without professional experience is still possible, but the path looks different from a few years ago.</p><p>During the hiring boom of 2020 and 2021, it wasn’t unusual to hear stories about people learning to code for a few months, building a portfolio, and quickly landing a junior role.</p><p>Companies are now more selective, junior openings attract a lot of applicants, and beginners are often competing not only with other self-taught developers but also with computer science graduates and developers who already have some professional experience.</p><p>For many people, becoming genuinely job-ready may take a year or more of consistent learning and practice. The exact timeline depends on how much time you can put in, what you already know, and how quickly you move from lessons into building things on your own.</p><h3>Stick with a learning path</h3><p>One of the easiest ways to slow yourself down is to keep switching resources.</p><p>You start a JavaScript playlist on YouTube, move to a bootcamp course, try another platform for a week, discover a different roadmap on Reddit, and suddenly you’ve spent a month learning the same introductory concepts five different ways.</p><p>A structured path usually works better.</p><p>If you prefer short lessons and want something you can use on your phone as well as your computer, Mimo is an approachable place to start. Its lessons are designed to be completed in small sessions, which can make it easier to stay consistent when you don’t have hours available every day.</p><p>The Odin Project takes a very different approach.</p><p>It gets you working in a real development environment early. You’ll use the command line, Git, documentation, and your own code editor rather than having everything prepared inside a browser exercise.</p><p>That makes it more difficult, but the difficulty is useful. You start getting comfortable with the kinds of problems developers actually run into when they’re working independently.</p><p>freeCodeCamp is another good starting point, especially if you want to practise directly in the browser.</p><p>The exercises give you quick feedback and make it easy to experiment without spending much time setting things up. It’s particularly useful while you’re getting comfortable with HTML, CSS, and JavaScript.</p><p>Just make sure you eventually move beyond browser exercises and start building projects in your own development environment.</p><p>Once you already understand the fundamentals, Full Stack Open is an excellent way to go deeper.</p><p>The University of Helsinki course covers modern React, Node.js, APIs, testing, TypeScript, and other parts of full-stack development. It’s more demanding than the beginner-friendly options, so it makes more sense after you already know some JavaScript and web development.</p><p>You don’t need to use all of these.</p><p>Pick one main path, use other resources when you need another explanation, and keep moving forward.</p><h3>Learn the fundamentals before chasing frameworks</h3><p>It’s tempting to jump straight into React because that’s what you see in job descriptions.</p><p>Try not to rush it.</p><p>Start with HTML, CSS, and JavaScript.</p><p>Learn how to structure pages with semantic HTML. Get comfortable with responsive layouts using Flexbox and Grid. Understand forms, accessibility, browser events, and how the DOM works.</p><p>Then spend serious time on JavaScript.</p><p>You should be comfortable working with arrays, objects, functions, events, asynchronous code, Promises, and APIs before relying heavily on a framework.</p><p>Frameworks change, but the JavaScript underneath them doesn’t change nearly as quickly.</p><p>Once those fundamentals feel comfortable, start learning the tools that appear frequently in modern web development.</p><h3>Add TypeScript once your JavaScript is solid</h3><p>JavaScript should come first, but TypeScript is worth adding fairly early.</p><p>TypeScript helps catch mistakes while you’re writing code and makes it easier to understand what kind of data different parts of an application expect.</p><p>You’ll see it in a lot of modern React and front-end projects.</p><p>Start with simple concepts such as typing variables, functions, objects, and component props.</p><p>Then learn interfaces, unions, generics, and how to describe data coming back from an API.</p><p>Don’t worry about learning every advanced TypeScript feature.</p><p>The goal is to become comfortable enough that you can open a TypeScript project and work without immediately reaching for any every time the compiler complains.</p><h3>Learn modern React without skipping the basics</h3><p>Once you understand JavaScript, React becomes much easier to learn.</p><p>Start with components, props, state, events, and hooks.</p><p>But don’t stop once you know how to use useState and useEffect.</p><p>Understand how data moves through your application.</p><ul><li>Why does a component re-render?</li><li>Where should state live?</li><li>When should you keep something local to one component, and when does it need to be shared?</li><li>How do you fetch data and handle loading or error states?</li><li>How do you build an interface that works properly with a keyboard and screen reader?</li></ul><p>Those questions matter more than memorizing a long list of React APIs.</p><p>Once React itself feels comfortable, you can start exploring frameworks such as <a href="https://nextjs.org/">Next.js</a>.</p><p>Next.js introduces things like routing, server rendering, server components, and different ways of loading data.</p><p>You don’t need to start there on your first week of learning React. Add it once you already understand the basics.</p><h3>Learn enough backend development to understand the whole application</h3><p>Even if your goal is front-end development, some backend knowledge makes you much more useful.</p><p>You should understand what happens after the browser sends an API request.</p><ul><li>Learn the basics of Node.js and how servers handle requests.</li><li>Build a few simple APIs.</li><li>Understand HTTP status codes, authentication, cookies, and error handling.</li><li>And learn a relational database.</li></ul><p>PostgreSQL is a strong choice because relational databases are widely used in production applications. Learning SQL also teaches you how data is structured and how different pieces of information relate to each other.</p><p>You can use tools such as Prisma or Drizzle later to make database work easier, but learn some SQL first so you understand what’s happening underneath.</p><p>MongoDB is still worth knowing, but you don’t need to build every beginner project around the classic MongoDB, Express, React, and Node stack just because many tutorials do.</p><p>The important thing is understanding the concepts well enough to choose the right tool for the project.</p><h3>Learn how real development work is done</h3><p>Writing code is only one part of being a web developer.</p><p>You also need to know how that code gets tested, reviewed, and deployed.</p><p>Start with Git.</p><p>Don’t just make one giant commit after finishing the project.</p><p>Create branches. Make smaller, clear commits. Learn how pull requests work. Get comfortable resolving merge conflicts.</p><p>Then learn some basic testing.</p><p>For JavaScript and TypeScript applications, tools such as Jest or Vitest are useful places to start.</p><p>You don’t need to test every line of code. Focus on important behaviour.</p><p>If someone submits a form, does the right thing happen?</p><p>If an API request fails, does the user get a useful error?</p><p>If someone isn’t logged in, can they access something they shouldn’t?</p><p>Later, you can learn tools such as Docker and GitHub Actions.</p><p>They’re useful, but don’t feel like you need to understand containers and CI/CD before you’ve built your first application.</p><p>Add these skills gradually as your projects get more serious.</p><h3>Build projects that aren’t just tutorial copies</h3><p>Your portfolio is where you prove that you can do more than follow instructions.</p><p>There is nothing wrong with building a to-do app, weather app, or clone while you’re learning.</p><p>Almost everyone builds simple projects at the beginning.</p><p>The problem is making those the centerpiece of your portfolio without changing or expanding them.</p><p>A stronger project gives you decisions to make.</p><p>Think about something connected to your interests, previous work, or everyday life.</p><p>You could build a scheduling tool for a small local business.</p><p>You could create an inventory system for a hobby you know well.</p><p>You could build a sports statistics dashboard, budgeting application, study planner, or booking platform.</p><p>The project idea doesn’t have to be completely original.</p><p>You just need to make it your own and work through problems that aren’t already solved for you in a tutorial.</p><p>If you can get even a small number of real people to use it, you’ll learn things you wouldn’t have noticed yourself.</p><h3>Keep your GitHub easy to understand</h3><p>Hiring managers may look at the code behind your portfolio projects.</p><p>Make it easy for them.</p><p>Give important repositories a proper README.</p><p>Explain what the project does, which technologies you used, how to run it, and where the live version is hosted.</p><p>If you made an interesting technical decision, explain that too.</p><p>Your commits don’t need to be perfect, but try to make them understandable.</p><p>A history like:</p><p>Add user authentication</p><p>Handle failed API requests</p><p>Fix mobile navigation</p><p>tells a much clearer story than one giant commit called:</p><p>final</p><p>The same applies to the code itself.</p><p>Use sensible names. Keep files organized. Remove old commented-out code. Run a formatter and linter.</p><h3>Find ways to get experience before your first developer job</h3><p>The phrase “no experience” can be misleading.</p><p>You may not have worked as a developer yet, but you can still get experience solving real problems for other people.</p><ul><li>Look around your local area or your existing network.</li><li>Maybe a small business has an outdated website.</li><li>Maybe someone is manually tracking appointments in a spreadsheet.</li><li>Maybe a local club needs a better registration system.</li><li>You could offer to help with a small project.</li></ul><p>Once you’ve built something for someone else, you suddenly have much more to talk about in an interview.</p><p>That’s real experience, even if it didn’t happen inside a software company. Small freelance projects can serve the same purpose and so can open-source contributions.</p><p>Fixing a small bug, improving documentation, or helping with tests still gives you experience working with someone else’s codebase.</p><h3>Use your previous experience as an advantage</h3><p>If you’re changing careers, don’t treat your old experience like wasted time.</p><p>It can actually make you more interesting.</p><p>Suppose you’ve spent years working in healthcare, logistics, finance, marketing, education, or another industry.</p><p>A software company building products for that industry may value someone who understands both the technology and the problems its customers face.</p><p>A developer can learn a framework, but understanding an industry deeply can take years.</p><p>Look for ways to connect what you already know with the kinds of software projects you build and the companies you apply to.</p><h3>Use AI to help you learn, not to avoid learning</h3><p>AI coding tools can be extremely useful.</p><p>They can also make it easy to skip the exact part of programming that you need to practise.</p><p>If you ask AI to build every component, fix every bug, and write every function, the project may work while your understanding barely improves.</p><p>Then you get into an interview and have to explain the code without help. Use AI more like a tutor, ask why an error is happening and to review code you already wrote or point you toward the part you should investigate.</p><p>Then try to solve the problem yourself.</p><p>The idea is to make sure you’re still learning while using AI to help you.</p><h3>When should you start applying?</h3><p>You don’t need to wait until you’ve learned everything on this list.</p><p>You never will.</p><p>Start applying once you have solid fundamentals and a couple of projects you can explain confidently.</p><p>You should be able to open one of your projects and talk about:</p><ul><li>Why you built it.</li><li>How the application is structured.</li><li>How the data is stored.</li><li>What problems you ran into.</li><li>How you handled authentication or API requests.</li><li>What you’d improve if you had more time.</li></ul><p>You should also be able to build smaller things without following a tutorial step by step.</p><p>That doesn’t mean you’ll know the answer to every interview question.</p><p>Junior developers aren’t expected to know everything.</p><p>Employers mainly need to see that you understand the fundamentals, can solve problems, and can learn when you encounter something unfamiliar.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=792ea563d1e1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Should a Front-End Developer Portfolio Include?]]></title>
            <link>https://medium.com/@srdan_82278/what-should-a-front-end-developer-portfolio-include-ac570d53b2f0?source=rss-a1dc9ceea991------2</link>
            <guid isPermaLink="false">https://medium.com/p/ac570d53b2f0</guid>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[job-search-tips]]></category>
            <dc:creator><![CDATA[Srdan Borovic]]></dc:creator>
            <pubDate>Mon, 24 Aug 2026 17:53:35 GMT</pubDate>
            <atom:updated>2026-08-24T17:53:35.052Z</atom:updated>
            <content:encoded><![CDATA[<p>A hiring manager opens your portfolio. You probably have less time than you think to make a good impression.</p><p>They won’t read every word or carefully inspect every animation. They’ll scan the page, open a project or two, maybe check your GitHub, and decide fairly quickly whether your work is worth a closer look.</p><p>For a front-end developer, that makes the portfolio especially important. It’s not just a place to display your projects. The portfolio itself is one of your projects.</p><p>If it’s slow, awkward on mobile, difficult to navigate, or full of accessibility problems, that says something about your front-end skills before anyone even reaches the project section.</p><p>So what should actually be in it?</p><h3>Start by making it clear who you are</h3><p>The top of your portfolio shouldn’t make people guess what you do.</p><p>Say what kind of developer you are, mention your main technical focus, and give people somewhere obvious to go next.</p><p>Something like:</p><p><strong>Front-end developer building accessible web applications with React and TypeScript.</strong></p><p>That’s enough.</p><p>You don’t need a clever title like “Digital Alchemist” or “Code Ninja.” They might sound more interesting, but they don’t help someone work out whether you’re a fit for a React developer position.</p><p>Under your introduction, give visitors two clear options: view your projects or contact you.</p><p>The quicker someone understands who you are and what you can do, the better.</p><h3>Your projects are the most important part</h3><p>Everything else on the portfolio supports your project section.</p><p>This is where someone gets to see whether you can build software rather than simply list technologies on a resume.</p><p>Keep the layout easy to scan. A simple grid of project cards works well. Each card can show the project name, a short description, and the main technologies you used.</p><p>For every important project, include three things.</p><p><strong>First, a live version.</strong></p><p>Deploy the application somewhere reliable so people can actually use it. A screenshot tells someone what the project looks like. A live demo lets them see whether it works.</p><p><strong>Second, link to the source code.</strong></p><p>A public GitHub repository gives reviewers the chance to look at your project structure, code quality, naming, commits, and documentation.</p><p><strong>Third, explain what you actually did.</strong></p><p>This doesn’t need to be a huge case study. A few useful paragraphs are enough. Explain what problem you were trying to solve, the main decisions you made, anything difficult you ran into, and what you learned or improved.</p><p>That last part is often what makes a project interesting.</p><p>Saying that an app has authentication, filters, and a dashboard tells someone what you built. Explaining why you chose a particular state-management approach or how you fixed a performance problem shows how you think.</p><p>That’s much more valuable in an interview.</p><h3>Choose projects that show different skills</h3><p>Not every project adds the same amount of value to a portfolio.</p><p>A basic counter or to-do list is perfectly fine while you’re learning, but it probably shouldn’t be the main thing you show employers. Hiring managers have seen hundreds of them, and they don’t give you much room to demonstrate problem-solving.</p><p>Try to include projects with more depth.</p><p>A data dashboard, for example, can show that you know how to fetch information from an API, handle loading and error states, filter data, and update the interface when something changes.</p><p>An e-commerce project gives you a chance to work with cart logic, prices, filters, saved sessions, authentication, and possibly a test payment flow.</p><p>A real-time application, such as a chat app, can demonstrate that you understand updates happening without a full page refresh.</p><p>A small component library can be another strong project, especially if you document it properly and pay attention to accessibility, reusable patterns, and keyboard behaviour.</p><p>You don’t need all of these.</p><p>Three or four strong projects that demonstrate different skills are usually better than ten projects that all do roughly the same thing.</p><p>And there’s nothing wrong with starting from something you built during a course.</p><p>Platforms such as <a href="https://mimo.org/">Mimo</a> are useful for learning the fundamentals through structured projects and exercises. The important part is what you do afterwards.</p><p>If a course gives you a basic task manager, don’t just change the colours and publish it.</p><p>Take it further.</p><p>Add user accounts. Save the data properly. Add search and filtering. Improve the state handling. Connect it to a real backend. Add drag-and-drop. Make it work offline.</p><p>Once you’ve changed the project enough that you had to make your own technical decisions, it starts becoming evidence of your ability rather than evidence that you completed a lesson.</p><h3>Keep the skills section simple</h3><p>You should include your technical skills, but there’s no need to turn them into a chart.</p><p>Skill bars like:</p><p><strong>JavaScript: 90%</strong></p><p><strong>React: 85%</strong></p><p>don’t really tell anyone anything.</p><p>What does 90% knowledge of JavaScript mean? There’s no useful way to measure it, and the numbers are completely subjective.</p><p>A simple list is much easier to understand.</p><p>You could group your skills into categories like:</p><ul><li>Languages</li><li>Frameworks and libraries</li><li>Testing</li><li>Build tools</li><li>Databases</li><li>Design and styling</li></ul><p>That way, someone looking specifically for React, TypeScript, Jest, or Next.js can find the answer immediately.</p><p>The projects can then show how well you actually use those tools.</p><h3>Make it easy for people to contact you</h3><p>If someone likes your work, contacting you should take almost no effort.</p><p>Include your email address or a simple contact form, along with links to your LinkedIn and GitHub profiles.</p><p>If you use a contact form, test it properly. A beautiful form that never sends the message is worse than simply displaying an email address.</p><p>It’s also useful to offer a downloadable version of your resume.</p><p>Keep that resume clean and easy for applicant tracking systems to read. You don’t need to put your full home address on a publicly available document either. Your city or general location is usually more than enough if location matters.</p><h3>Treat your portfolio like a real front-end project</h3><p>This is the part that can make or break the whole thing.</p><p>If you’re applying for front-end roles, people will judge the portfolio itself.</p><p>Start with responsive design.</p><p>Your website should work properly on a laptop, tablet, and phone. Nothing should spill off the screen. Text should remain readable. Navigation should still work. Buttons and links should be easy to tap.</p><p>You don’t need an elaborate mobile design. You just need a layout that adapts properly.</p><p>Accessibility matters too.</p><p>Use semantic HTML where it makes sense instead of building the entire page from generic containers. Use actual buttons for actions and actual links for navigation. Add proper labels to form fields. Check your colour contrast.</p><p>Try navigating the entire portfolio with your keyboard.</p><p>Can you see which element is focused?</p><p>Can you open the menu?</p><p>Can you reach every project and contact link?</p><p>These are simple checks, but they tell you a lot about the quality of the website.</p><p>Performance matters for the same reason.</p><p>If your portfolio takes several seconds to load because every image is a massive PNG and five animation libraries start running at once, that’s not a great demonstration of front-end work.</p><p>Compress images. Use modern image formats where appropriate. Give images proper dimensions. Lazy-load content that doesn’t need to appear immediately.</p><p>Run the site through Lighthouse or another performance tool and fix the obvious problems.</p><p>You don’t need a perfect score. You just want the site to feel quick and stable.</p><p>Add basic metadata too. A proper page title, description, favicon, and social sharing image make the site feel finished.</p><h3>Expect people to look at your GitHub</h3><p>If someone likes a project, there’s a good chance they’ll open the repository.</p><p>Make sure what they find doesn’t look abandoned.</p><p>Every important project should have a useful README explaining what the project does, which technologies it uses, how to run it locally, and where the live version is hosted.</p><p>If the project has an unusual architecture or setup, explain that too.</p><p>Your commit history doesn’t have to look like it came from a senior engineer with ten years of experience. Just try to make it understandable.</p><p>A series of small commits like:</p><ul><li><strong>Add product filtering</strong></li><li><strong>Fix mobile navigation</strong></li><li><strong>Handle API loading state</strong></li></ul><p>is more useful than one giant commit called <strong>final final version.</strong></p><p>Keep your formatting consistent as well. Tools like <a href="https://eslint.org/">ESLint</a> and <a href="https://prettier.io/">Prettier</a> can help, but the bigger goal is simply to make the repository easy for another developer to understand.</p><p>That’s what clean code is really about.</p><h3>Don’t make the design harder than it needs to be</h3><p>Your portfolio should have some personality, but it’s easy to go too far.</p><p>Heavy animations, custom cursors, long loading screens, 3D navigation, and complicated scroll effects can look impressive when they work.</p><p>They can also make the site slower and harder to use.</p><p>If someone has to figure out how your navigation works before they can see your projects, the design is getting in the way.</p><p>You don’t need to prove that you’re a professional visual designer unless that’s part of the job you’re targeting.</p><p>A clean layout, good typography, consistent spacing, and a sensible colour palette are enough. You can use a design system, a component library, Tailwind CSS, or your own styling.</p><p>What matters is that the interface feels polished and doesn’t distract from the work you’re showing.</p><p>Your strongest design choice might simply be knowing when to stop.</p><h3>Keep the portfolio focused</h3><p>You usually need:</p><ul><li>A clear introduction.</li><li>A handful of strong projects.</li><li>A simple skills section.</li><li>Some information about your background.</li><li>Links to your GitHub, LinkedIn, resume, and contact details.</li></ul><p>That’s enough.</p><p>Everything else should earn its place.</p><p>If you’ve written useful technical articles, include them. If you have testimonials from clients or collaborators, those can help too. If you’ve contributed to open-source projects, show that work.</p><p>But don’t add sections just because another developer’s portfolio had them.</p><h3>Conclusion</h3><p>Your portfolio should give someone clear proof of your front-end skills.</p><p>Show a few substantial projects rather than dozens of small exercises. Give people live demos and source code. Explain the decisions behind the work rather than listing features.</p><p>Keep your skills easy to scan and your contact information easy to find.</p><p>Then make sure the portfolio itself demonstrates the things you’re claiming to know.</p><p>Skip the percentage bars and unnecessary gimmicks.</p><p>If someone can open your portfolio, understand what you do, try your projects, inspect your code, and contact you without having to search for anything, you’ve done the important part.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ac570d53b2f0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>