Three Things In The “Very Easy” Tier Are Not Programming Languages
A note before anything else: we have written about this chart before. In “Which language should I learn first? Wrong question.” we took the caption’s advice and ran with it – name what you want built, and the language falls out downstream. That post is the practical one. If you want to be told what to learn, read that one.
This post is about something different: what the six tiers are actually measuring, and why one of them contains three things that are not programming languages.
Look at tier one, Very Easy. Scratch, Python, HTML, CSS, SQL, BASIC.
HTML is a markup language – it describes the structure of a document. CSS is a stylesheet language – it describes how that document should look. SQL is a query language – you describe the rows you want and the database works out how to get them. None of the three is a general-purpose programming language, and that is not pedantry. It is the whole explanation for why they are in tier one.
They feel very easy because they leave out the part that is actually hard. You cannot write a loop in HTML. There are no variables holding state that changes while your program runs, no branching you have to trace in your head, no “why did this value become 7”. Those four things – control flow, state, branching, debugging your own mental model – are what people mean when they say programming is hard. Remove them and of course what is left is easy.
So tier one is not one tier. It is “three languages that are genuinely gentle to start” sitting next to “three languages that are easy because they are a different kind of thing”.
The card this post is about
Watch the original reel: “Programming & Development Languages – A Beginner’s Learning Guide”
Thirty-four languages in six tiers, subtitled “Based on syntax, concepts, tooling and typical use cases. Difficulty varies by background and goals.” The table below reproduces every entry as printed.
One number, three measurements
The card’s own subtitle is unusually honest about this: the tiers are based on syntax, concepts, tooling and typical use cases. Four things, folded into one number from 1 to 6. Pull them apart and they do not move together at all.
| Axis | What it measures | Lowest on the card | Highest on the card | Where the card’s tiers get it wrong |
|---|---|---|---|---|
| 1. Syntax steepness | How much ceremony stands between you and a working “hello world” | Scratch, Python, BASIC | Assembly, C++ | COBOL is in tier 6 and its syntax is famously verbose but plain English. It is filed low because of where it lives, not how it reads |
| 2. Concept load | How many genuinely new ideas you have to hold in your head at once | HTML and CSS – close to zero. No loops, no state | Rust (ownership), Haskell (purity), Erlang (concurrency) | This is the axis that actually predicts whether you quit, and it is the one the tier number hides |
| 3. Tooling friction | How much you must install, configure and understand before you can run anything | Scratch, Python, HTML | C and C++ (build chains), Verilog (hardware) | Swift sits in tier 3, but its real cost for many people is that it needs a Mac. That is not syntax |
| 4. Distance from your goal | How far the language leaves you from the thing you wanted to have built | Whichever one your goal needs | Scratch, for almost any real goal | Scratch is tier 1 and ships nothing. Swift is tier 3 and puts an app on your phone. On this axis the order reverses |
Read the last row twice, because it is the one that costs people a month. On the axis that matters most – how close this gets me to the thing I want – the tier order inverts. Scratch is the easiest language on the card and the furthest from any outcome an adult wants. Swift is harder and lands you exactly where you were trying to go.
The card is not claiming otherwise. Its footer says so plainly: “Difficulty is a guide only. Pick a language that fits your goal.” But a picture of six coloured tiers argues louder than a line of grey text, and the picture says start at the top.
All thirty-four, as printed
Here is the full chart. Column 2 is the card’s own wording, including its one-line descriptions, which are better than most charts bother with.
| Tier (card’s label) | The entries, with the card’s own one-line descriptions | Our note (not on the card) – checked 8 October 2026 |
|---|---|---|
| 1 Very Easy “Great for complete beginners” |
Scratch visual blocks · Python clean & readable syntax · HTML learn web structure (markup) · CSS style web pages (easy to start) · SQL easy to start; advanced queries take practice · BASIC simple commands | Mixed tier. HTML, CSS and SQL are not general-purpose programming languages – they are easy because they have no loops or mutable state. SQL carries the only difficulty curve on the whole card (“easy to start; advanced queries take practice”), and that hedge is true of every entry here |
| 2 Easy “Widely used and beginner-friendly” |
JavaScript learn logic and build for web · PHP simple syntax, widely used · Ruby readable syntax · Lua simple and lightweight · R great for data analysis · Go simple syntax, modern language | The most honest tier on the card. All six are real general-purpose languages with low syntax cost. JavaScript’s true difficulty is not the language – it is the ecosystem you meet in month two |
| 3 Moderate “Requires more concepts and practice” |
TypeScript builds on JavaScript · Java OOP concepts, widely used · C# modern and versatile · Kotlin modern, concise (similar to Java) · Swift used for iOS/macOS apps · Dart used for Flutter apps | Notice four of the six descriptions name a destination, not a difficulty – iOS, Flutter, “builds on JavaScript”. This tier is sorted by goal already, which is what the caption recommends |
| 4 Challenging “Steeper learning curve, more complex concepts” |
C low-level, pointers, memory management · C++ more complex features · Rust ownership & borrow checker · MATLAB used for numerical computing · Scala functional + OOP concepts | C, C++ and Rust belong here on concept load. MATLAB does not – its syntax is gentle and its users are often not programmers. It is here for its domain, like tier 6 |
| 5 Advanced “Less common paradigms or specialized use cases” |
Haskell functional programming · Clojure functional (Lisp dialect) · Erlang concurrency focused · Elixir functional programming · Julia high-performance scientific computing · Ada used in critical systems | “Less common paradigms” is not the same as “hard”. Elixir and Julia are pleasant to write; what is unfamiliar is the way of thinking, not the difficulty of the keystrokes |
| 6 Specialized “Domain-specific / low-level” |
Assembly low-level hardware control · COBOL legacy systems (business) · Verilog / VHDL hardware description languages · Fortran widely used in scientific computing · Prolog logic programming | This tier is honest about not being a difficulty tier – the label says domain-specific. COBOL reads like English; Fortran is described on the card itself as “widely used”. They are here for where they are used |
The tiers describe month one. Nobody quits in month one.
This is the part that matters most and it is the part no difficulty chart can show.
Month one is wonderful. The syntax is new, every exercise works, the tutorial author has removed every obstacle in advance, and you finish each session with something on the screen. Difficulty in month one is almost entirely syntax, which is exactly what the card measures – and measures well.
Month three is where people stop. And what makes month three hard has nothing to do with how the language reads. It is the gap between knowing the language and having built the thing. Nobody abandons Python because of its indentation. They abandon it because they finished the course, opened an empty file, and discovered that “I know Python” and “I can build the thing I wanted” are two completely different states.
A chart sorted by month-one steepness therefore answers a question nobody is actually stuck on. The caption on this reel knows it – “what do you want to have built by Christmas?” is a month-three question dressed as a beginner question, and it is the right one. We took that thread all the way through in the companion post.
So here is the thing the chart cannot give you: what actually goes wrong in month three, and what to do about each one.
| What stops you in month three | What it feels like | Which tier it hits | The fix |
|---|---|---|---|
| 1. The blank file | You can follow any tutorial and start nothing on your own | Every tier. Tier 1 worst, because the on-ramp was smoothest | Make the first project embarrassingly small and already specified – rebuild something that exists, so you never have to decide what it should do |
| 2. The tooling cliff | The language was fine; the build system, environment or package manager was not | Tiers 2-4. JavaScript and C are the classic ones | Treat the toolchain as a separate subject with its own hour, instead of a tax on learning the language |
| 3. The concept wall | One idea you cannot get past – pointers, ownership, async, recursion | Tiers 4-5, by design | This is the only one where the tier number genuinely warned you. Expect it, timebox it, and do not read it as evidence you are not a programmer |
| 4. No reason to continue | Nothing is broken. You simply stop opening the editor | Every tier, and the most common of the four | A deadline and somebody expecting it. This is the one the chart cannot help with at all |
Row four is the honest answer to “which language should I learn first”. For most people the language was never the variable. The variable was whether anything downstream of the learning was going to happen.
Four honest caveats
This is one of the better charts we have taken apart. It carries a disclaimer in the subtitle (“Difficulty varies by background and goals”), a one-line description under every single entry, and a footer that tells you not to use it as a ranking. The caption goes further and says the ranking question is the wrong question entirely. Almost none of the tool cards we have looked at – a sixty-logo grid with no descriptions at all, for instance – do any of those three things. Credit where it is due.
SQL’s description is the model for the whole chart. “Easy to start; advanced queries take practice” is the only entry with a curve rather than a point, and that curve is true of every language on the card. Python is tier 1 to start and tier 5 the moment you meet async or packaging. Difficulty is a function of how far in you are, and a single tier number can only name the first inch of it.
AI changes one axis and not the others. A coding assistant flattens syntax steepness almost to nothing – you no longer have to remember the exact incantation. It does very little for concept load, because you still have to know whether the answer is right, and nothing at all for the blank file or for having a reason to continue. If anything it widens the gap between the two: the easy axis got easier and the hard ones did not move.
Our reading is dated and partly judgement. The tier contents are the card’s, read off the reel on 8 October 2026. The axis assignments in our columns are our opinion, not fact – someone who learned C first will tell you pointers are simpler than JavaScript’s build tools, and they will have a case.
The one-line version
Three of the six things in the easiest tier are not programming languages, and that is the clearest evidence that the tier number is measuring several things at once. Separate them and the chart becomes much more useful: syntax steepness, concept load, tooling friction, and distance from your goal – and only the last one predicts whether you will ever finish anything.
On that last axis the tiers run backwards. The easiest entry on the card ships nothing; the one that puts an app on your phone sits in tier three.
So use the chart for what it is good at – telling you roughly how the first month will feel – and get the actual decision from the caption, which already contains it: what do you want to have built by Christmas? Then go and read the companion post, which is the practical half of this one.
Learning a lot does not make anyone good. Doing a lot does. Knowing a language and having built something with it are two different states, and the chart can only see the first one.
If you want to be held to the second, we run a free challenge at BANI Academy. There is no barrier to entry – you commit a small fee that is refunded when you finish, and the only requirement is that you actually do the work for the length of the challenge. It is aimed squarely at row four of that last table: having a deadline and somebody expecting the thing.
Which month did your last attempt end in – and was it really the language? Tell us in the comments under the original reel.
More on building a channel for a global audience at mmoyoutube.com.
