Building Coding Skills Through Consistent Practice

How I’ve Practiced the (Coding + Programming for AI) Fundamentals for 5+ Years As a PhD student working in AI, I keep my fundamentals sharp with a simple routine that still works in 2025: 1- Pen & paper first I start ideas, proofs, and algorithms in a notebook. In a world of TikTok, Reels, and constant notifications, handwriting forces me to slow down, think clearly, and stay intentional instead of reactive. 2- Coding discipline Python: I regularly revisit Python Crash Course by Eric Matthes and build small projects to refresh core patterns. C / C++ & DSA: Abdul Bari’s playlists https://lnkd.in/gex5EcKp for theory, then NeetCode for problem-solving. Depth check: Elements of Programming Interviews in Python to see problems from multiple angles and stress-test my understanding. 3- Machine learning with real math The Hundred-Page Machine Learning Book by Andriy Burkov keeps concepts and math tight. Python Machine Learning by Example by Yuxi (Hayden) Liu for implementing algorithms with NumPy first, then with scikit-learn / TensorFlow / PyTorch. Nothing too crazy just consistent, fundamentals-first work that transfers directly into building real-world AI systems.

A few years ago, I mentored a young professional eager to transition into data science. He had enrolled in multiple bootcamps, downloaded several Jupyter notebooks, and even joined several learning communities. But after months, his progress was minimal. When I asked what her daily routine looked like, she replied, “I mostly read through the codes and run the notebooks to see what happens.” That was the moment I realized many people “learn” programming without ever truly programming. The Common Mistake Most beginners consume content passively, watching tutorials, scrolling through code samples, or running prepared scripts. It feels productive, but it’s deceptive. You’re observing code, not internalizing it. You’re copying others’ logic, not building your own problem-solving muscles. Programming is a muscle skill, not a memory skill. And like any muscle, it only grows through deliberate, consistent practice. The Framework That Works I always teach beginners this simple progression: Watch → Type → Tweak → Build → Repeat. 1. Watch: Understand what the code is meant to do. 2. Type: Don’t just run it. Type every line yourself in your IDE (VS Code, RStudio, or Jupyter). 3. Tweak: Change something intentionally, a function name, variable, or dataset and see what breaks. That’s where learning lives. 4. Build: Start a small project that solves your problem, no matter how simple. 5. Repeat: Two hours daily is better than ten hours once a week. Consistency transforms confusion into confidence. Why It Matters for Data Scientists and Global Health Professionals In global health and development, programming isn’t just about code, it’s about turning messy data into meaningful action. Whether you’re analyzing HIV outcomes, forecasting disease trends, or visualizing impact indicators, your ability to manipulate data directly shapes the insight you can produce. When you code actively, typing, testing, and iterating, you’re not just learning syntax. You’re training your mind to think logically, troubleshoot systematically, and approach public health problems like a true data scientist. Your Turn Ask yourself: Are you reading code, or are you writing it? Are you building the confidence to solve problems — or just watching others do it? Start small. Code daily. Break things. Fix them. That’s how you grow from learning programming to thinking like a programmer. #DataScience #Programming #AIForGood #AnalyticsForImpact #SIAnalytics #GDIN #GlobalHealth

Someone recently asked me: How did you get good at coding through self-study? Here's the story. In August 2014, I stumbled upon Python at AIMS-Ghana. I didn’t fully understand what was happening. I just knew I loved it. Two weeks after, they gave us a mini-project. Solve 10 Project Euler problems ➔ https://lnkd.in/eBC3NqGM Mathematical challenges that would take forever by hand. Perfect. I love math. I’m also falling for coding. This felt like home. I’d brainstorm with colleagues, scribble solutions on paper, translate them into code, and wait nervously… hoping not to hit an error message or fall into an infinite loop. 😅 Solving those 10 problems didn’t make me great at coding. They were just the start. What happened next changed everything: I got addicted to that green checkmark. Every correct answer felt like a small victory. So, I kept coding… daily. Problem 11. Problem 12. Problem 22. Sometimes my code ran until the next morning. Sometimes it crashed. Sometimes I got it wrong and spent hours digging through Stack Overflow. But I kept showing up. No accountability partner. No one reminding me to code. Just curiosity and love pulling me in. That love carried me beyond the computer lab. First, Coursera’s Python for Everybody course. Then data structures and algorithms. Each course feeding my hunger to understand more. By dissertation time, something beautiful happened: I wasn’t just learning anymore… I was creating. I implemented an algorithm for maximum matchings in bipartite graphs. With my supervisor’s guidance, that messy code became a real Python package ➔ https://lnkd.in/eRuiwh7p Thousands downloaded it within months. At present, 200+ GitHub repositories and 3 Python packages depend on it. The journey that started with curiosity about green checkmarks became the foundation for my PhD scholarship in computing at Glasgow. Here's the lesson this experience taught me: ↳ Coding consistently is what builds skill. Show up daily, even if it’s messy. ↳ Let curiosity guide you. Follow fascination, not pressure. ↳ You won’t become a Python wizard overnight – I didn’t. But slow and steady, you’ll grow. ↳ Don’t walk the journey alone. Have people to lean on when your code breaks (trust me... it will). When you love what you’re learning, consistency becomes effortless. #LearnWithSofiat

If I had to learn how to code from scratch in 2025… I wouldn't waste any time on "fake learning". I wouldn’t build another Spotify clone. I wouldn't watch 100 YouTube tutorials. I wouldn’t chase every new trending JavaScript framework. If I had to start again, here's exactly what I'd do 👇 I’d start small, and build real things. → Learn Git. → Master one programming language (Java, Python, or C#). → Write small scripts that automate something simple. → Learn to call APIs and connect to real data. → Build an end-to-end project: frontend → backend → database → deploy. → Host your projects on AWS. → Provision your infrastructure through code using AWS CDK or Terraform. → Think about automation, CI/CD, security, testing and observability. → Read open source code to see how professionals think. → Need project ideas? Check out John Crickett's Coding Challenges platform and Neo Kim's System Design Newsletter. Then, I’d join a community: → This ensures you're held accountable. → Share what you're building and learn with others. → Get feedback on your work. Don't work in isolation.  → Looking for a community? Join Alex and Rahul's Taro (YC S22) platform. → Also, stay connected to the industry by reading Gergely's The Pragmatic Engineer blogs. The real formula to learning to code is simple: projects, consistency and community. That's how you build skill, momentum and confidence. Because learning to code isn’t about finishing 100 tutorials. It’s about solving problems, making mistakes, and learning from every iteration. Start small, and build something real. Ship it. Do that a few times, and your work will speak louder than any CV. Keep building. Keep learning. And stay curious. #softwareengineering #learnandbecurious

𝗜’𝘃𝗲 𝘁𝗿𝗮𝗶𝗻𝗲𝗱 𝟱𝟬+ 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 — 𝗮𝗻𝗱 𝘁𝗵𝗲𝘆 𝗮𝗹𝗹 𝗺𝗮𝗸𝗲 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝗺𝗶𝘀𝘁𝗮𝗸𝗲. They reread notes. Rewatch tutorials. But rarely 𝘁𝗲𝘀𝘁 what they actually understand. That’s the biggest trap in learning — confusing 𝗳𝗮𝗺𝗶𝗹𝗶𝗮𝗿𝗶𝘁𝘆 with 𝗺𝗮𝘀𝘁𝗲𝗿𝘆. When I was learning my first programming language, I did the same thing — endless repetition, zero retention. Until I discovered Richard Feynman’s principle: “If you can’t explain it simply, you don’t understand it well enough.” That line changed how I learn — and how I teach. Now I use five proven methods that turn learning into a system: 𝗧𝗵𝗲 𝗙𝗲𝘆𝗻𝗺𝗮𝗻 𝗧𝗲𝗰𝗵𝗻𝗶𝗾𝘂𝗲 — simplify until it’s crystal clear. 𝗔𝗰𝘁𝗶𝘃𝗲 𝗥𝗲𝗰𝗮𝗹𝗹 — test yourself, don’t just reread. 𝗧𝗵𝗲 𝗟𝗲𝗶𝘁𝗻𝗲𝗿 𝗦𝘆𝘀𝘁𝗲𝗺 — repeat less, remember more. 𝗔𝗜 𝗣𝗿𝗼𝗺𝗽𝘁𝘀 — use AI to explain, quiz, and summarize. 𝗧𝗵𝗲 𝗛𝗮𝗿𝘃𝗮𝗿𝗱 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 — spaced repetition, self-testing, and feedback loops. And most importantly — 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲 𝗶𝗺𝗺𝗲𝗱𝗶𝗮𝘁𝗲𝗹𝘆. Real understanding doesn’t happen in your head. It happens in action. Since then, I’ve learned faster — and helped others do the same. Because smart learning isn’t about IQ. It’s about 𝗶𝘁𝗲𝗿𝗮𝘁𝗶𝗼𝗻 𝗮𝗻𝗱 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗲. 💬 What’s one learning habit you’d change if you could start over? — Natan Mohart

consistency is everything 👀. And no, not everyone knows this. Especially when it comes to: • Learning Data Structures & Algorithms • Mastering a programming language • Building projects • Preparing for interviews • Cracking FAANG-level companies People think it’s about brilliance. Or shortcuts. Or some “smart guy” gene. But here’s what they don’t tell you — It’s not brilliance. It’s boring consistency. Let’s break this down. why most learners quit too early • They jump in with unrealistic expectations. — 50 questions in 10 days, 1 project every weekend. • They copy someone else’s strategy without adapting it. — What worked for a CS grad at Stanford might not work for you. • They focus only on finishing tasks, not understanding them. — Leetcode streaks aren’t useful if you can’t explain your solution. • They expect motivation to carry them through. — But motivation is a sprint. Consistency is a marathon. how the best stay consistent — even when no one is watching • They learn how to learn. — They don’t just memorize solutions. They ask: Why does this work? What if the input was different? • They don’t try to do everything. — One language. One roadmap. One platform. They simplify. • They break problems down into patterns. — Not 1000 questions. Just 20 patterns. Arrays, two pointers, recursion, DP, graphs. • They timebox their practice. — 90 minutes/day > 6 hours once a week. • They review mistakes. — Not just “wrong answer” — but why it was wrong. They keep a “mistake log.” • They don’t overconsume. — Watching 20 YouTube tutorials ≠ understanding. They build while they learn. proven techniques that help with long-term consistency • Spaced repetition — Especially for algorithms, syntax, time complexity. Tools like Anki help. • Active recall — Close the tab. Re-explain the problem from memory. If you can’t, you don’t know it. • Project-led learning — Learn React? Build a weather app. Learn REST APIs? Create a blog backend. Build while learning. • Accountability systems — Pair up with someone. Join a Discord server. Share your streak publicly. • System-first, goal-second — Focus on building a system: 2 problems/day, 1 project/month. Let results follow. behind every job offer at Google, Amazon, Microsoft? You’ll find: — Someone who failed 10 mocks but didn’t stop — Someone who revised that DP pattern 5 times until it clicked — Someone who solved 300 problems and remembered 50 deeply — Someone who built one solid project and could explain every line of it so, if you’re stuck, tired, or doubting? You don’t need a new tutorial. You don’t need a new language. You don’t need someone else’s path. You need a system. You need depth. You need the ability to sit with the hard stuff — again, and again. Because consistency is everything. It’s not the flashy answer. It’s just the one that works. #ProblemSolving #ConsistencyWins #DSA #LearningHowToLearn #NoShortcuts #SoftwareEngineering #CrackTopTech

🎾 Learning LLM coding by reading Hacker News is like learning tennis by watching Wimbledon. I just had a tough conversation with a developer named Robert. When I asked what he'd been doing to improve his skills with AI tools, he said: "Just reading mostly blogs and Hacker News and everything, but not practicing itself." My response: "So... watching people play tennis on TV as opposed to playing tennis?" His answer: "Yeah, pretty much." This is completely unacceptable in 2025. Here's the reality: You need 1,000 hours of prompting practice. Not reading about prompting. Not watching videos about what other people are building. Actually prompting. What the doers are doing: → Running multiple concurrent conversations with LLMs → Never editing files by hand—reviewing diffs and prompting → Constantly asking: "How can we do this better?" → Creating verification scripts, pre-commit hooks, more tests → Updating docs so mistakes don't repeat → Iterate, iterate, iterate I told Robert directly: "You have very limited time. Either you start swinging the racket immediately and show me results, or you won't be part of this team." To be clear: this isn't about reckless coding. It's about optimizing productivity while maintaining quality gates. Skilled developers are responsible for gating the process at every level: → At the commit level → At the pull request level before merging to main or feature branches → At staging before anything touches production → At production deployment As Steve Yegge says in the video, it's like the difference between harvesting corn by hand vs. factory farming. You're not being careless—you're using better tools with proper safeguards in place. Developers who can't make this shift will be left behind. Not by me—by the industry. The gap between those who are actually using these tools and those who are just reading about them widens every single day. Stop watching tennis on TV. Pick up the racket. 📺 Watch this Steve Yegge interview: https://lnkd.in/gxUWqQDj #VibeCoding #AI #SoftwareDevelopment #LLM #ClaudeCode #Programming #TechLeadership #DeveloperProductivity #AIAssisted #Engineering

To get better at coding, you need consistency more than you need intensity. Intensity: - Learn 5 programming languages. - Solve 10 coding challenges in a day. - Try to build multiple projects at once. - Try to learn multiple technologies at once. - Binge-watch coding tutorials over the weekend. - Dive deep into advanced topics without mastering the basics. Consistency: - Learn one programming language well. - Solve 1-2 coding challenges every day. - Focus on one project at a time and complete it. - Master one technology before moving to the next. - Dedicate time each week to learn new concepts in depth. - Regularly allocate time for coding, even if it's just 30 minutes. Intensity makes a good story. Consistency makes progress.

To prepare for technical interviews at FAANG (Google, Apple, Microsoft, Amazon, and Meta), here's strategy: To prepare for technical interviews, focus on solving coding problems regularly. 1. Practice Coding Every Day:   - Try solving at least one medium or two easy-level coding questions daily.   - Do it on your own without help, but if you're stuck for over an hour, look for hints or solutions.   - Make notes of what you missed while solving and revise them often. 2. Focus on Concepts:   - Spend time understanding the concepts behind each problem you solve.   - Revise your notes and practice problems regularly to strengthen your understanding. 3. System and Design Studies:   - Aim to prepare at least one system and one object-oriented design case study each week. 4. Stay Consistent:   - Consistency is key. Stick to your daily coding practice routine.   - Use the Pomodoro Technique: plan 25 minutes of focused preparation followed by a 5-minute break, and repeat. 5. Include Behavioral Interviews:   - Don't overlook behavioral interviews. Give them equal importance in your preparation. For effective use of LeetCode: 1. Quality Over Quantity:   - Focus on solving quality problems rather than just solving many.   - Follow a roadmap of quality problems, like the 100 Days to GAMAM plan. 2. Use Curated Lists:   - Solve LeetCode's curated list of top interview questions, including the top 100 liked questions. 3. Practice Weak Areas:   - Identify your weak areas and practice questions specifically in those topics.   - Sort problems by "Acceptance" after choosing a difficulty level for better chances of success. 4. Gradual Progression:   - If you're a beginner, start with easy-level problems and gradually move to medium and hard levels.   - Aim to solve a target number of problems at each level. 5. Utilize Resources:   - Check out multiple solutions to problems and understand their time and space complexities.   - Take notes on missed concepts and revise them regularly. 6. Challenge Yourself:   - Once you're comfortable with practice, try daily challenges and participate in contests.   - Track your progress and consistency using LeetCode's features, like session management and submission graphs. LeetCode Practice:   - Solve LeetCode problems daily for 1-2 hours.   - Focus on quality over quantity.   - Start with easy problems if you're a beginner.   - Practice topics where you feel weak.   - Check out multiple solutions for each problem.   - Aim for a balanced number of easy, medium, and hard problems. Problem Solving Techniques:   - Don't spend more than 45-60 minutes on a problem.   - If stuck, check hints or solutions, but try to understand them fully.   - Take notes on missed concepts and solutions.   - Revise problems frequently, following a schedule based on Ebbinghaus's Forgetting Curve. consistent practice, understanding concepts, and targeted preparation will help you ace your technical interviews! Follow Vikram Gaur #faang

𝐈 𝐰𝐢𝐬𝐡 𝐬𝐨𝐦𝐞𝐨𝐧𝐞 𝐭𝐨𝐥𝐝 𝐦𝐞 𝐭𝐡𝐢𝐬 𝐢𝐧 𝐦𝐲 𝟏𝐬𝐭 𝐲𝐞𝐚𝐫 𝐨𝐟 𝐜𝐨𝐥𝐥𝐞𝐠𝐞… In my 1st year of college, I thought programming was just about: ➡️ Building projects ➡️ Getting placed With no mentorship, I learned from YouTube. It worked until my project crashed in a hackathon and I failed a DSA question in an MNC interview. That’s when I realized: 🍁 Building features is easy. 🍁 Being reliable and understandable makes you a real developer. If you want to move from half-done projects to real work, build these 5 habits : 1) 𝐂𝐨𝐝𝐞 𝐬𝐦𝐚𝐥𝐥 𝐭𝐡𝐢𝐧𝐠𝐬 𝐞𝐯𝐞𝐫𝐲 𝐝𝐚𝐲 Consistent daily practice, even just solving one easy problem or writing a small function, helps you build momentum and prevents burnout from long, occasional coding sessions. 𝐄𝐱𝐚𝐦𝐩𝐥𝐞: Solve one LeetCode problem or write one utility function each day instead of cramming on weekends. 2) 𝐓𝐞𝐬𝐭 𝐚𝐧𝐝 𝐫𝐮𝐧 𝐛𝐞𝐟𝐨𝐫𝐞 𝐭𝐡𝐞 𝐝𝐞𝐦𝐨 Always run and test your code before sharing it, because catching bugs early ensures your project works as intended and saves embarrassment later. 3) 𝐋𝐞𝐚𝐫𝐧 𝐭𝐨 𝐞𝐱𝐩𝐥𝐚𝐢𝐧 𝐲𝐨𝐮𝐫 𝐜𝐨𝐝𝐞 𝐨𝐮𝐭 𝐥𝐨𝐮𝐝 Being able to clearly explain what your code does shows that you truly understand it and helps solidify your learning. 4) 𝐂𝐨𝐦𝐩𝐥𝐞𝐭𝐞 𝐒𝐦𝐚𝐥𝐥 𝐏𝐫𝐨𝐣𝐞𝐜𝐭𝐬 Completing small projects teaches integration, edge cases, and polish, which half-finished features never do. 𝐄𝐱𝐚𝐦𝐩𝐥𝐞: Build a to-do app, push it to GitHub, then iterate by adding features or improving design. 5) 𝐊𝐞𝐞𝐩 𝐚 𝐬𝐢𝐦𝐩𝐥𝐞 𝐛𝐮𝐠 𝐥𝐨𝐠 𝐚𝐧𝐝 𝐫𝐞𝐟𝐥𝐞𝐜𝐭 Writing down the bugs you fix and reflecting on their cause helps you identify patterns and prevents repeating the same mistakes. Coding is a journey, not a sprint. Making mistakes, seeing your app crash, and facing failed projects are all part of the process Everyone developer you see has once gone through this stage. "Progress comes from the habits you build, not the shortcuts you seek." #FAANG #Leetcode #CodingJourney #ProgrammingHabits #BeginnerDev #Consistency #GitHub #LearnByDoing #DSA #Freshers