About Teach Yourself Coding

Teach Yourself Coding is a free learning site for people who want to understand software, not just copy code.

The site is built around a simple idea:

If we understand why something works, we can rebuild it when the tools change.

Programming languages change. Frameworks change. Libraries come and go. AI coding tools are changing how we write software again.

The fundamentals underneath them change much more slowly.

That is what we try to teach here.

Why this site exists

I have been building software for more than two decades.

During that time, I have worked on enterprise applications, banking and fintech systems, analytics platforms, developer tools, low-code frameworks, distributed systems, cloud applications, web applications, and software products.

And I am still learning.

One thing I have noticed over the years is that many developers know how to use a framework but do not always know what problem the framework is solving.

We learn React before understanding the browser.

We learn an ORM before understanding SQL.

We use message queues before understanding why asynchronous communication is useful.

We use async and await before understanding what they are actually doing.

And now we can ask an AI coding agent to build an entire application before we fully understand the code it generated.

That can make us productive very quickly.

It can also leave large gaps in our understanding.

Teach Yourself Coding exists to help close those gaps.

Learn from first principles

Most tutorials start with an API.

We often start one step earlier.

Before using a router, we may build a tiny router ourselves.

Before using a database abstraction, we may look at what happens underneath it.

Before using a data grid library, we may build a data grid from scratch.

Before depending on a framework feature, we try to understand the problem that feature was designed to solve.

The goal is not to rebuild every library we use in production.

The goal is to understand enough of the machinery that the library no longer feels like magic.

Once you understand the idea, the API becomes much easier to learn.

Build things

A large part of this site follows a simple pattern:

Understand the problem → build a small version → improve it step by step → understand the real-world solution.

You will find tutorials where we build things such as:

• libraries and frameworks
• UI components
• databases and storage engines
• developer tools
• APIs and backend services
• distributed systems
• AI agents
• coding agents
• MCP servers and tools
• complete applications

Sometimes the thing we build is deliberately small.

That is useful.

A 200-line implementation that you completely understand can teach you more than a 200,000-line framework that you only know how to configure.

What we teach

The subjects change as software changes, but the main areas include:

• AI-assisted software development
• AI agents and agentic systems
• learning and coding effectively with LLMs
• programming from first principles
• building libraries and frameworks from scratch
• JavaScript and TypeScript
• Python
• Go
• C, C#, Zig, and other systems languages
• React and modern frontend engineering
• Node.js and backend development
• SQL and databases
• data structures and algorithms
• concurrency and asynchronous programming
• design patterns
• system design and software architecture
• distributed systems
• cloud engineering on AWS, Azure, and GCP
• developer tools and engineering practices

This is not intended to become an encyclopedia of programming.

We would rather explain fewer things properly than publish hundreds of shallow articles.

AI changes how we learn to code

AI coding tools are now part of software development.

We use them too.

The goal of Teach Yourself Coding is not to pretend that developers should go back to writing every line manually.

It is the opposite.

We want developers to become good enough at understanding software that they can use AI effectively.

If Claude, Codex, Copilot, ChatGPT, or another coding agent generates 500 lines of code, you should be able to look at the structure and understand most of what is happening.

You should know what questions to ask.

You should recognize suspicious code.

You should know where abstractions belong.

You should be able to test the result.

And when the AI gets something wrong, you should have enough understanding to fix it.

AI can make us much faster.

But speed is far more useful when it is combined with understanding.

How we explain things

We try to keep the language simple without simplifying the technical idea.

That distinction matters.

You will see diagrams, small programs, experiments, worked examples, and step-by-step implementations.

When useful, we explain the same idea at different levels.

First, we might explain it in plain English.

Then we look at the code.

Then we look at what is happening underneath.

Then we discuss how the same idea appears in production systems.

Our test is simple:

If we cannot explain an idea clearly, we probably do not understand it well enough yet.

So we go back and work on the explanation.

Who is behind Teach Yourself Coding

Teach Yourself Coding is led by Rajesh Pillai, a software developer, architect, educator, and co-founder of Algorisys Technologies.

Rajesh has spent more than two decades building software across enterprise systems, fintech, analytics, web applications, cloud platforms, developer tooling, low-code systems, and software products.

But this site is not built around the idea of an expert standing on a stage giving answers.

It is built around learning.

Many tutorials begin because we want to understand something ourselves.

We investigate it.

We reduce it to the smallest useful idea.

We build it.

We break it.

We rebuild it.

Then we document what we learned.

That is also why you will sometimes see older articles rewritten completely. Software changes, and our understanding changes too.

Teach Yourself Coding also includes material from other experienced engineers who have spent years building real production systems.

The common requirement is that the material should come from experience, experimentation, or careful study rather than simply repeating documentation.

Who this site is for

Teach Yourself Coding is for anyone who wants to become better at understanding software.

You might be:

• learning your first programming language
• a working developer filling gaps in your fundamentals
• an experienced developer learning a new area
• preparing for a technical interview
• moving toward software architecture
• learning system design
• learning AI-assisted coding
• trying to understand code generated by AI
• or simply curious about how software works underneath

You do not need a computer science degree.

You also do not need to memorize everything.

You need curiosity and a willingness to experiment.

Free access

The learning material on Teach Yourself Coding is free to read.

There is no paywall required to begin learning and no account is required just to read the tutorials.

Where possible, we also publish working code, examples, repositories, diagrams, and other supporting material.

The site is still growing.

Some subjects have complete learning paths. Others may start with only a few articles and expand over time.

That is intentional.

Teach Yourself Coding is not a finished textbook.

It is a continuously evolving collection of things we are learning, building, testing, and trying to explain better.

One final principle

There is a sentence that captures most of what we are trying to do here:

Simplify the language, not the idea.

Software engineering can be difficult.

The explanation does not have to be.