Why Some Programming Languages Feel Harder Than Others

Have you ever looked at a piece of code and thought:
"Why does this have to be so complicated?"
Programming languages are supposed to help us communicate instructions to computers. But sometimes, the language itself can feel like another problem we have to solve.
I've used and experimented with several programming languages, and one thing I've noticed is that the difficulty of programming isn't always the same as the difficulty of the language you're using.
Two languages can perform the exact same task while making the programmer write completely different things.
So what actually makes one programming language feel harder than another?
Syntax plays a huge role
Consider a simple condition.
In Python:

if number > 10:
    print("The number is greater than 10")
else:
    print("The number is 10 or less")

Once you're familiar with Python, this is straightforward.
But imagine you're completely new to programming.
You now have to understand:
What if means
What > means
Why there's a :
Why the code underneath is indented
Why print() has parentheses
None of these things are particularly difficult individually.
But when you're learning programming for the first time, every additional piece of syntax is another thing you have to remember.
Compare that with a more English-oriented approach:

if number is greater than 10 then
    print "The number is greater than 10"
else
    print "The number is 10 or less"
end

The second example is longer.
But you can almost read it as a sentence.
This is one of the ideas behind languages such as Python and Avery: making code readable instead of relying entirely on symbols.
Symbols aren't necessarily bad
This doesn't mean symbols are bad.
Quite the opposite.
Symbols can make code significantly shorter.
For example:
if x > 5:
is much shorter than:
if x is greater than 5 then
For someone who already understands programming, the first version may actually be preferable.
The problem isn't necessarily the syntax itself.
The problem is how much knowledge the programmer needs before the syntax becomes intuitive.
This is why experienced programmers can look at code that seems completely confusing to beginners and immediately understand it.
They've already built the mental model.
The "learning curve" isn't just about syntax
Syntax is only one part of the problem.
Another major factor is the number of concepts you need to understand before you can accomplish something.
Take generating a random number.
In Python, you might write:

import random

number = random.randint(1, 100)

That's perfectly reasonable.
Python's module system is powerful and extremely useful.
But for a beginner, there are multiple concepts involved:
import
↓
module
↓
random
↓
function
↓
arguments
Now compare that with an English-oriented approach:

set number to random number between 1 and 100

The programmer doesn't necessarily need to understand modules before they can generate a random number.
This is something I've been experimenting with in Avery.
The idea is simple:
If something is common enough, why make the beginner learn another concept before they can use it?
Of course, this approach has its own disadvantages.
Putting too much functionality directly into a language can make the language larger and harder to maintain.
So there's a balance.
Familiarity changes everything
There's another interesting phenomenon:
The language you're familiar with almost always feels easier.
If you've been programming in JavaScript for five years, JavaScript probably doesn't feel complicated anymore.
If you've been using Python for five years, Python probably feels natural.
You stop thinking about the syntax.
You just write it.
This means that when programmers argue about which language is "easy," they're often comparing their own experiences.
A beginner might look at:

if (number > 10) {
    console.log("Greater");
}

and think it looks complicated.
A JavaScript developer might look at the exact same code and think:
"That's incredibly simple."
Neither person is necessarily wrong.
They're just at different points on the learning curve.
Good syntax can reduce the initial barrier.
I think the most interesting question isn't:
"Which syntax is objectively the easiest?"
It's:
"How quickly can someone become comfortable with this syntax?"
That's a much more useful measurement.
A language could have incredibly powerful features, but if a beginner needs to spend weeks learning its syntax before they can build anything, that creates a significant barrier.
On the other hand, a language could have extremely simple syntax but become frustrating once you try to build larger programs.
The ideal is somewhere in the middle.
Easy to start.
Hard to outgrow.
This is something I'm experimenting with
I've been working on a small programming language called Avery, partly to explore this exact question.
The goal isn't to create "the best programming language."
There are already thousands of languages, each with different strengths.
Instead, I'm interested in exploring how far you can take readability-first language design.
For example:

set name to ask "What's your name? "

print "Hello, " + name + "!"

Or:

set number to ask "Enter a number: "

if number % 2 is 0 then
    print "Even"
else
    print "Odd"
end

The code is still programming.
You still need to understand variables, conditions and operators.
But the syntax tries to make the intention obvious.
And that's really the experiment.
But there's a catch
Making a language easy to read doesn't automatically make it easy to build.
In fact, designing a programming language has made me realize how many things programmers normally take for granted.
You need to deal with things like:
Lexing
Parsing
Variables
Scope
Expressions
Functions
Runtime errors
Type handling
Loops
Data structures
File operations
Tooling
You can make the surface syntax look simple while having a surprisingly complicated system underneath it.
That's probably one of the biggest lessons I've learned from building a language.
Simple-looking code doesn't necessarily mean a simple language.
So which approach is better?
I don't think there's a single answer.
Symbol-heavy syntax can be concise.
English-like syntax can be readable.
Minimal languages can be easier to learn.
Large languages can provide enormous amounts of functionality.
And languages with complex syntax can still be incredibly productive once you know them.
Ultimately, programming languages are tools.
The important question isn't:
"Which language is the easiest?"
It's:
"Which language makes it easiest for me to express the ideas I have?"
That's something I've been thinking about a lot while developing Avery.
And I don't know yet whether an English-oriented approach is actually better.
That's what I'm trying to find out.
What do you think?
What makes a programming language feel difficult to you?
Is it syntax?
The number of concepts you need to learn?
The tooling?
The documentation?
Or something else entirely?
And if you've designed or worked on a programming language before, what would you prioritise: readability, simplicity, conciseness, or power?