DEV Community: Shankar

I Had No Idea What Coding Was 6 Months Ago. Here's Everything I Wish Someone Had Told Me.

Shankar — Tue, 17 Mar 2026 03:18:36 +0000

Six months ago, I Googled "what is coding" and got seventeen different answers that all assumed I already knew what coding was.
That's the problem with most beginner resources. They're written by people who have forgotten what it actually feels like to know absolutely nothing. This article isn't that. This is the beginner's guide I desperately needed — written honestly, with no assumed knowledge and no skipped steps.
If you're reading this because you're curious about coding but have no idea where to start, you're in exactly the right place.

So — what actually is coding?
Coding is the process of giving instructions to a computer in a language it can understand.
That's it. That's the whole definition.
Your computer is extraordinarily powerful but also completely literal. It cannot make assumptions, fill in gaps, or use common sense. It does exactly what it is told — nothing more, nothing less. Coding is the skill of writing those instructions clearly enough that the computer does what you actually intend.
The "languages" you write these instructions in are called programming languages. Python, JavaScript, HTML, C++, Java — these are all different languages with different rules, different uses, and different strengths. Just like human languages, they have grammar (called syntax), vocabulary (called keywords), and structure. And just like human languages, you get better at them the more you use them.

Why do people learn to code?
People learn to code for very different reasons, and understanding your reason matters because it determines what you should learn first.
To get a job in tech — Software development, web development, data science, DevOps. These are among the most in-demand and well-paid careers in the world right now. A developer with two to three years of solid experience can earn between $60,000 and $150,000+ depending on location and specialisation.
To freelance and work from anywhere — Coding is one of the few skills that is genuinely location-independent. Thousands of developers work remotely, set their own hours, and choose their clients. The infrastructure for this has never been more accessible.
To build something of your own — An app, a website, a tool that solves a problem. The ability to build things yourself — without depending on expensive agencies or developers — is transformative for entrepreneurs, creators, and anyone with an idea.
To understand the world better — Software runs almost everything. Healthcare, finance, education, entertainment, communication. Understanding how it works — even at a basic level — changes how you see and navigate the modern world.

The 5 core concepts every beginner needs to understand
Before you write a single line of code, understanding these five concepts will make everything else click faster.

Variables A variable is a labelled box that stores a piece of information. You give it a name and put something inside it — a number, a word, a list. Later in your code, you can refer to the box by name instead of repeating the value. Example: name = "Sarah". Now every time your code says name, the computer knows you mean "Sarah."
Functions A function is a reusable set of instructions that you write once and can use as many times as you need. Instead of writing the same twenty lines every time you want to do something, you write it once as a function, give it a name, and call that name whenever you need it. This is how developers avoid repeating themselves — and how large programs stay manageable.
Loops A loop tells the computer to repeat an action a certain number of times — or until a condition is met. Instead of writing "do this" one hundred times, you write "do this one hundred times" once. Loops are how code handles repetitive tasks — processing lists, checking data, running calculations across large datasets.
Conditionals A conditional tells the computer to make a decision. "If this is true, do this. Otherwise, do that." This is how programs respond differently to different inputs. If the user enters the right password, let them in. If not, show an error message. Every interactive program in the world is built on conditionals.
Data structures Data structures are organised ways of storing multiple pieces of information. A list, for example, stores many items in order. A dictionary stores items as labelled pairs — like a real dictionary that pairs a word with its definition. Knowing which data structure to use for a given problem is one of the first real skills a new developer builds.

Which programming language should you start with?
This is the question every beginner asks. The honest answer is: it matters less than you think, but here is a clear recommendation anyway.
Start with Python if your goal is data science, automation, AI, or you simply want the gentlest possible introduction to programming. Python reads almost like plain English. Its syntax is clean and forgiving. It is the most widely recommended first language for beginners for good reason.
Start with HTML and CSS if your goal is to build websites and see immediate visual results. Strictly speaking, HTML and CSS are not programming languages — they are markup and styling languages — but they are the foundation of everything visual on the web and the most beginner-friendly starting point if front-end development interests you.
Start with JavaScript if your goal is web development and you want to build interactive, dynamic websites. JavaScript runs in every browser in the world. It is the only language that works natively on both the front end and the back end of web development, which makes it one of the most versatile first languages available.
Do not start with C++ or Java. Both are powerful but unnecessarily complex for absolute beginners. They will frustrate you before you understand enough to appreciate why they're designed the way they are.

The honest truth about the learning curve
Coding is not as hard as people make it sound. But it is also not as easy as some beginner marketing suggests.
The first two weeks are the hardest. Everything is new, the error messages are confusing, and the gap between what you're trying to build and what you can currently build feels enormous. This is completely normal. Every developer alive went through this exact phase.
The breakthrough moment — when things start to click, when you can look at a problem and begin to see how code might solve it — typically arrives around week four to six for most consistent learners. It doesn't arrive all at once. It arrives slowly, then suddenly.
The developers who make it through are not more talented than the ones who quit. They are more consistent. Thirty minutes every day for sixty days will take you further than three-hour sessions twice a week. Daily contact with the material is how the brain builds the pattern recognition that makes coding feel natural.

Where to start for free today
You do not need to spend money to begin. Here are the best genuinely free starting points:

freeCodeCamp.org — Structured curriculum from zero to employable. Covers HTML, CSS, JavaScript, Python, and more. Completely free with certifications.
The Odin Project — One of the most respected free full-stack web development curricula. Project-based and community-supported.
CS50 by Harvard (on edX) — The best introduction to computer science available anywhere, at any price. Free to audit. Genuinely excellent.
Codecademy — Interactive in-browser lessons with immediate feedback. Free tier covers the basics well.

Start with one. Finish it before starting another. The biggest mistake beginners make is jumping between resources because something "looks better." Depth in one place beats breadth across five.

The one thing that separates beginners who make it from those who don't
Build things.
Not tutorials. Not exercises. Actual things — however small, however broken, however ugly.
A personal website. A script that renames your files. A quiz app. A to-do list. It doesn't matter what. The act of building something real forces you to encounter and solve problems that no tutorial will ever show you. Those problems — the confusing error messages, the things that don't work the way you expected — are where the real learning happens.
Every tutorial you complete teaches you what someone else decided you should know. Every project you build teaches you what you actually need to know. There is no substitute for this.
Ready to go deeper?
If this article gave you a clear picture of what coding is and you're ready for a structured guide that takes you from zero to writing your first real programs — the ebook "What is Coding? A Beginner's Guide" is exactly what comes next. It covers everything in this article in much greater depth — including language comparisons, a step-by-step first project, and a clear 30-day roadmap designed specifically for people starting from scratch. I recommend it to anyone who wants a single, clear, well-structured resource rather than piecing together a dozen different tutorials:learn more.
One last thing
The best time to start learning to code was a year ago. The second best time is today — right now, before you finish reading this sentence.
Open freeCodeCamp. Read the first lesson. Write the first line. That's all. The rest takes care of itself from there.

If this helped you understand coding for the first time — drop a reaction or share it with someone who's been on the fence about starting. And feel free to ask any beginner questions in the comments. No question is too basic here.

I Coded Every Day for 365 Days — Here's the System That Made It Stick

Shankar — Mon, 16 Mar 2026 03:19:54 +0000

I used to open my laptop at 11pm, stare at a blank editor, write three lines, close it, and call it practice.
That wasn't practice. That was guilt management.
After 30 days of that cycle, I had learned almost nothing. I had a GitHub contribution graph that looked like a heartbeat monitor for someone who was barely alive. And I had zero confidence that I was actually getting better.
Then I changed the approach entirely. Not the hours — the system. And 365 days later, coding daily had become the most natural part of my day. This article is exactly what changed and why it worked.

The real reason most developers quit daily practice
It's not laziness. It's ambiguity.
When you sit down to "practice coding" without a specific target, your brain doesn't know what success looks like. So it defaults to the path of least resistance — scrolling tutorials, re-reading documentation, or building the same to-do app for the fourth time.
The solution isn't motivation. It's structure. Specifically: a system that tells you exactly what to do before you open your editor.

The system that actually works

One skill, one week Instead of practicing everything loosely, dedicate a full week to a single concept. Arrays one week. Recursion the next. REST APIs the week after. This sounds slow. It is the opposite of slow — depth creates speed. When you spend seven days with one concept, you stop skimming the surface. You hit the walls, get stuck, work through it, and come out the other side with genuine understanding instead of surface familiarity.
The 25-minute minimum rule Forget the idea of "coding for an hour." Start with a commitment of 25 minutes — nothing less, nothing more required. This removes the activation energy barrier that kills consistency. Twenty-five minutes is never too long to start. And 80% of the time, once you start, you keep going. The goal of this rule is not to limit your sessions. It is to make starting non-negotiable.
Build something ugly The biggest enemy of daily practice is the pursuit of clean code before understanding. Give yourself explicit permission to write ugly, inefficient, redundant code — especially in the first half of any new concept. Understanding comes before elegance. Always. Developers who insist on clean code from day one write almost nothing. Developers who ship ugly code and refactor it learn twice.
The end-of-session note After every session — even a 25-minute one — write one sentence: "Tomorrow I will start by ___." Leave the editor open on the exact file you'll return to. This is the highest-leverage habit in the entire system. It eliminates the startup cost of the next session. You open your laptop and you already know exactly what you're doing. No decision fatigue. No warm-up. Just work.
Weekly review: three questions Every Sunday, answer these three questions in a notebook:

What did I build or practice this week?
What concept still feels unclear?
What is the one thing I will focus on next week?

This takes ten minutes. It creates continuity between weeks, stops you from drifting, and gives you a record of how far you've come — which matters more than you expect when motivation dips.

What to actually practice (the honest list)
The most common question is: what do I practice?
Here is a prioritised list based on what builds real, transferable skill fastest:

Coding challenges (daily) — LeetCode Easy and Medium, HackerRank, or Codewars. Even 1–2 problems per session. The benefit is not the algorithm — it is the habit of thinking through problems methodically.
Build small, complete things — A weather app. A budget tracker. A simple API. Completion matters more than complexity. Every finished project teaches something no tutorial can.
Read other people's code — Go to GitHub, find a project in your language, and read 50–100 lines of production code. This builds pattern recognition faster than almost anything else.
Rebuild things you use — Tried to build a simplified version of a tool you use daily? Even a basic clone of something familiar forces you to think architecturally, not just syntactically.

The mindset shift that holds it all together
Here is the uncomfortable truth about daily coding practice: the days when you least want to do it are the days it matters most.
Not because suffering builds character. Because consistency is a skill. And consistency is built precisely in the moments when you do the thing anyway — not the moments when it felt easy and enjoyable.
The developers who grow the fastest are not the most talented. They are the most consistent. Twenty-five minutes every day, for twelve months, produces a developer who is unrecognisable from where they started.
You do not need more motivation. You need a better system. And now you have one.

Want to go deeper?
I've been recommending the ebook "How to Practice Coding Every Day" to any developer who asks me about building this habit properly. It covers the full system — skill sequencing, resource selection, how to track progress without burning out, and how to structure practice around a full-time job or studies. If this article resonated, that book takes it several levels further:learn more.

Why Every Programmer Should Learn Algorithms (Beginner Guide)

Shankar — Sun, 15 Mar 2026 12:46:35 +0000

Introduction

When people start learning programming, they usually focus on learning a programming language like Python, C, or JavaScript.

But many beginners forget something even more important: algorithms and logical thinking.

Programming languages are just tools. What really makes a programmer effective is the ability to think logically and solve problems step by step.

This is exactly what algorithms help you do.

What Is an Algorithm?

An algorithm is simply a step-by-step procedure used to solve a problem.

You actually use algorithms in daily life without realizing it.

For example, making tea can be thought of as an algorithm:

Boil water

Add tea leaves

Add sugar or milk

Pour into a cup

Each step follows a clear order.
Programming works the same way.

When you write a program, you are basically writing an algorithm that the computer can follow.

Why Algorithms Are Important in Programming

Understanding algorithms helps programmers in many ways.

Better Problem Solving

Algorithms train your brain to break big problems into smaller steps.

Efficient Programs

Good algorithms make programs run faster and more efficiently.

Strong Programming Fundamentals

Many advanced topics in programming depend on algorithmic thinking.

Coding Interviews

Most technical interviews test algorithm and logic skills.

Because of this, algorithms are considered one of the core foundations of computer science.

Simple Example of an Algorithm

Let’s look at a very simple algorithm:

Finding the largest number in a list

Steps:

- Start with the first number as the largest
- Compare it with the next number
- If the next number is larger, update the largest value
- Continue until the list ends

This logical process can easily be converted into code in any programming language.

How Beginners Can Start Learning Algorithms

If you are just starting, here are some simple tips:

✔ Learn basic programming first
✔ Practice solving small problems
✔ Study common algorithm examples
✔ Focus on understanding logic instead of memorizing code

Consistency is more important than speed when learning algorithms.

Recommended Resource for Beginners

If you want a beginner-friendly introduction to algorithms and programming logic, you may find the ebook “Introduction to Algorithms and Logic” helpful.

It explains the fundamentals of algorithmic thinking and problem solving in a simple and easy-to-understand way.learn more.

Disclosure: This post contains an affiliate link. If you purchase through it, I may earn a small commission at no extra cost to you.

Final Thoughts

Programming is not only about writing code.
It is about learning how to think logically and solve problems effectively.

Algorithms help build this mindset.

If you invest time in understanding algorithms early in your programming journey, it will make learning new technologies much easier in the future.