DEV Community: Avery

What Makes a Programming Language Beginner-Friendly?

Avery — Wed, 09 Sep 2026 14:51:31 +0000

When someone starts learning programming, one of the first things they have to deal with is syntax.

Before they can build a game, automate something, or even make a simple calculator, they have to learn how to write the instructions in a way the computer understands.

But how much does syntax actually affect the learning experience?

I've been thinking about this while learning different programming languages and working on a small programming language of my own. It made me wonder:

What actually makes a programming language easy for beginners?

I think there are several factors.

1. Syntax should communicate intent

Consider a simple condition in Python:

if age > 18:
    print("You are an adult.")

Once you've learned Python, this is easy to understand.

But a complete beginner has to learn what if means, what > means, why there's a :, and why indentation matters.

Now consider a more English-oriented syntax:

if age is greater than 18 then
    print "You are an adult."
end

There is still syntax to learn, but the syntax itself communicates more of the meaning.

You don't necessarily need to remember that > means "greater than."

You can read:

age is greater than 18

and understand the intention.

This is something I've been experimenting with in a small programming language I'm developing called Avery.

The goal isn't necessarily to make syntax longer. It's to make the syntax more obvious.

2. Beginners shouldn't have to memorise everything

Another problem I think beginners encounter is having to remember the names of different functions and libraries.

For example, generating a random number in Python might look like:

import random

number = random.randint(1, 100)

There are several concepts here:
import
modules
random
randint
arguments
None of these concepts are inherently bad. In fact, modules are extremely useful for larger programs.

But for someone who has just started programming, it can feel like a lot.

I've been experimenting with an alternative approach in Avery:

set number to random number between 1 and 100

The language itself provides the functionality.

This doesn't mean imports are bad. They're extremely useful once a language becomes larger.

It's more about asking:

What should a beginner have to learn before they can do something simple?

3. Error messages matter

Eventually, every programmer gets an error.

Beginners probably encounter them even more often.

Consider an error such as:

NameError: name 'number' is not defined

An experienced programmer can immediately understand what's happening.

A beginner might wonder:

What's a NameError?

What's "defined"?

Where am I supposed to look?

Good error messages can make a huge difference.

Instead of merely telling someone that something went wrong, a language can try to explain what went wrong and where.

For example, an interpreter could say:

Avery Error: Line 4: "number" is not defined.

That's a small difference, but when you're learning, small differences matter.

4. Installation is part of the learning experience

Something that is often overlooked is what happens before you even write your first line of code.

If someone wants to try a language, they might have to:

Download the language.
Install it.
Configure the environment.
Install packages.
Configure an editor.
Figure out how to run the program.

For experienced developers, this may be completely normal.

For a beginner, it can be the hardest part.

Ideally, getting from:

"I want to try programming."

to:

Hello, world!

should be as short as possible.

This is another area where I'm trying to keep Avery simple.

5. Simplicity doesn't mean lack of power

There's an important trade-off here.

A language can be extremely easy to learn but become frustrating once you try to build something serious.

On the other hand, a language can provide enormous amounts of power while having a steep learning curve.

So I don't think the goal should be:

Make everything as simple as possible.

Instead, I'd say:

Make the simple things simple without making the complicated things impossible.

That's a much harder problem.

A calculator should be easy to write.

A beginner should be able to make a guessing game without reading hundreds of pages of documentation.

But if someone eventually wants to build something much more complicated, the language shouldn't suddenly become useless.

That's one of the challenges I'm trying to solve with Avery.

6. Consistency is underrated

Another thing that can make a language easier to learn is consistency.

If one part of a language works one way and another part works completely differently, beginners have to memorise more rules.

For example, if you learn that Avery variables are created with:

set name to "Alex"

then the rest of the language should ideally follow similarly predictable patterns.

The less arbitrary the language feels, the easier it becomes to build a mental model of how it works.

Once you understand the pattern, you can start predicting how something works instead of memorising every individual feature.

My experiment with Avery

These ideas are a major reason I'm building Avery.

I'm experimenting with a language where code tries to resemble natural instructions:

set number to ask "Enter a number: "

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

There is still programming knowledge involved.

You still need to understand variables, conditions, arithmetic and loops.

The difference is that I'm trying to make the syntax itself help explain those concepts.

Avery is capable of a lot and is still updating, and I'm finding out that designing a language is considerably harder than simply designing its syntax.

An idea can look great on paper and then turn into a completely different problem when you actually have to make an interpreter understand it.

That's been one of the most interesting parts of the project.

So, what actually makes a language beginner-friendly?

If I had to summarise it, I'd say:

Readable syntax
The code should communicate what it's doing.

Good errors
When something goes wrong, the programmer should know what happened.

Low initial friction
Getting started shouldn't be a project by itself.

Consistency
Learning one part of the language should help you understand another.

Room to grow
The language shouldn't become useless once the beginner becomes an intermediate programmer.

And perhaps most importantly:

A beginner should be learning how to solve problems, not just learning how to fight the language.

That's the idea I'm exploring with Avery.

I'm still figuring out where the line between simplicity and power should be.

What do you think?

What makes a programming language genuinely beginner-friendly to you?

Is English-like syntax actually useful, or does it just hide complexity?

And where do you think a language should draw the line between "easy to learn" and "powerful enough for serious development"?

Why Some Programming Languages Feel Harder Than Others

Avery — Wed, 09 Sep 2026 14:34:27 +0000

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?

I Built My Own Programming Language Because I Wanted Code to Read Like English

Avery — Tue, 08 Sep 2026 09:18:33 +0000

I’ve always found programming interesting, but there’s something about programming languages that bothered me.

You can know exactly what you want a program to do, yet sometimes the code required to express that idea feels much more complicated than the idea itself.

So I decided to try something:

What if I made my own programming language?

That language became Avery.

What is Avery?

Avery is a programming language I’m building with one main goal:
To make programming as easy to read and understand as possible.

I don't want someone learning Avery to constantly think about complicated syntax before they can even think about the problem they're trying to solve.

For example, here's a simple Avery program:

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

print "Hello, " + name + "!"

The intention is pretty obvious even if you've never programmed before.

Here's another example:

set number to ask "Enter a number: "

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

It's still programming, but I'm trying to make the code itself explain what it is doing.

No imports for common functionality

One of the design decisions I'm experimenting with is making commonly needed functionality available directly in Avery.

For example, generating a random number can simply be:

set number to random number between 1 and 100

There's no separate import statement to learn first.

The idea is that if someone wants a random number, they should be able to simply ask Avery for a random number. The same philosophy applies to other built-in capabilities such as time and other functionality.

Why make another programming language?

There are already countless programming languages. Python is beginner-friendly. JavaScript runs almost everywhere. C and C++ are incredibly powerful. Rust provides powerful safety guarantees. So I'm not trying to replace any of them.

I'm interested in finding out how far I can take the idea of making programming syntax feel natural while still allowing people to create increasingly complex programs. I want to see whether simplicity can be a fundamental design principle rather than just a feature.

Avery is still young

Avery is nowhere near the maturity of languages like Python, and I'm not pretending that it is. It's an actively developing project. Some features are incomplete. Some syntax will probably change. And I'm still figuring out what should and shouldn't be part of the language. But that's also what makes building it interesting.

I've already been using Avery to test increasingly complicated programs, and those tests have exposed problems in my interpreter that I wouldn't have found with simple "Hello, World!" programs.

Every time something breaks, I get to improve the language.

What I want Avery to become

My long-term goal isn't simply to create a language with a bunch of features. I want Avery to have an identity.

Simple syntax.

Readable code.

Minimal setup.

Useful built-in functionality.

And eventually, enough power that people can build genuinely interesting programs with it.

Try Avery

Avery is open source and I'm developing it publicly on GitHub.

Check out the project on GitHub: KageyaKo/Avery.

If you're interested in programming languages, interpreters, or language design, I'd genuinely like to hear your thoughts.

Especially criticism.

What would you change about Avery's syntax?

What functionality do you think should be built into the language?

And most importantly:
Would you actually want to program in a language like this?