Part 02 — Understanding C: What It Is, What It Can Do and Why It Still Matters

In the first part of this series, we looked at the story behind C and how it grew from the early work around Unix into one of the most influential programming languages in computing.

Now it is time to understand C itself.

Before writing our first program, it is useful to answer a few basic questions: What exactly is C? Where is it used? What can we build with it? Why is it still relevant today? And what makes it different from many of the languages we use for modern application development?

This part focuses on those questions in simple terms. We will not start with complicated syntax yet. First, we will understand what we are actually learning.

What Is C?

C is a general-purpose, compiled programming language used to build software and programs.

That definition is short, but there is much more behind it.

When we write a C program, we are writing instructions and logic that describe what the program should do. Those instructions can work with data, perform calculations, make decisions, repeat tasks, work with files, communicate with other parts of a system and, when required, work much closer to computer memory and hardware than many higher-level application languages normally do.

C is also a standardized programming language. The current international standard is ISO/IEC 9899:2024, which defines the form and meaning of C programs and is designed to support portability across different data-processing systems.

So, rather than thinking of C simply as “a language used to give instructions to a computer,” it is better to think of it as a language for building executable software while keeping a relatively close connection with how the computer works underneath.

Understanding C Through Four Layers

One easy way to understand C is to look at it from four different angles.

1. C as a Programming Language

At the most basic level, C is simply a language for writing programs.

We use it to express:

instructions
calculations
decisions
data
functions
program behaviour

For example:

int a = 10;
int b = 20;
int sum = a + b;

This small piece of code tells the program to store two values and calculate their sum.

As programs become larger, the same basic idea can be used to create much more complex software.

So, at this level:

C is the language we use to describe the logic and behaviour of a program.

2. C as a Compiled Language

There is another important part of understanding C: how our code becomes a program that the computer can run.

Suppose we create a file called:

program.c

This file contains the C source code written by the programmer.

A compiler then processes that source code and, together with the rest of the build process, produces a form that can be executed on the target system.

A simplified view looks like this:

C Source Code
      ↓
   Compiler
      ↓
Executable Program
      ↓
   Computer
      ↓
 Program runs

For example, when we write:

printf("Hello World");

we are writing C source code. The compiler and related tools turn that source into a program that the computer can execute.

This is why C is commonly described as a compiled language.

The important point for a beginner is simple:

We write C code as source code, and a compiler helps turn that code into an executable program.

The exact compilation and linking process can be more detailed than this, but we do not need to go deeper into it yet.

3. C as a General-Purpose Language

The word general-purpose simply means that C was not created for only one particular type of software.

You can use C for many different kinds of programs.

For example, C can be used in areas such as:

system software
embedded software
firmware
utilities
compilers
libraries
networking software
performance-sensitive software
hardware-related software

The important idea is that C is not tied to one specific field.

This is different from a technology designed mainly for one particular purpose.

For example, HTML has a specific job in web development: it describes the structure of a webpage. CSS focuses on presentation and styling. C, on the other hand, can be used to build many different types of executable software.

That is what makes it general-purpose.

4. C as a Systems-Oriented Language

This is where C becomes especially interesting.

C allows programmers to work relatively close to the computer's memory, data representation and system resources.

You will see this more clearly when we reach pointers and memory later in the series.

For example:

int x = 10;
int *p = &x;

At this stage, you do not need to understand every symbol in this example.

The important idea is that C gives us ways to work with where data is stored and how that data is accessed.

This level of control is one reason C has been widely used for system software and other software where efficient use of computer resources matters.

The Linux kernel is a good real-world example: its documentation states that the kernel is written in C, with some architecture-specific parts written in assembly.

So when we call C systems-oriented, we mean that it can be used to build software that works closely with the operating system, hardware and computer resources.

What Does C Actually Create?

This is an important question because beginners sometimes imagine that every programming language produces a particular kind of output.

C does not have one fixed type of output.

What you get depends on what you build.

A C program can produce:

numbers
text
calculations
files
command-line tools
background services
libraries
hardware behaviour
system-level software
parts of larger applications

For example:

printf("Hello World");

can produce text on the screen.

Another program could calculate scientific values.

Another could read and write files.

Another could control a device.

Another could become part of a much larger software system.

So C is not like CSS, where the main purpose is to control how something looks.

C is used to build the program itself and define what that program does.

C Compared With HTML, CSS and JavaScript

A simple comparison can make this much easier to understand.

Think about a website.

HTML

HTML describes the structure.

What elements are on the page?
Where is the heading?
Where is the paragraph?
Where is the button?

CSS

CSS controls the appearance.

What colour should it be?
How large should it be?
Where should it appear?
How should the page look?

JavaScript

JavaScript can control behaviour and interaction.

What happens when the user clicks?
What should change dynamically?
How should the page respond?

C

C is different.
C is used to build executable software and the logic behind that software.

What should the program do?
How should it process data?
How should it manage memory?
How should it interact with the system?

This does not mean C is “better” than HTML, CSS or JavaScript. They solve different problems.

The comparison simply helps us understand where C fits.

Where Is C Used?

C has been used in computing for decades, but its importance is not limited to old software.

It continues to appear in areas where performance, portability, predictable behaviour and close control over system resources are important.

Operating Systems and System Software

One of the clearest examples is the Linux kernel.

Linux kernel documentation states that the kernel is written mostly in C, with some architecture-dependent parts written in assembly.

This is a good example of where C's characteristics become useful. An operating system has to work closely with processors, memory, devices and other parts of a computer. C provides the kind of control needed for this type of work.

Embedded Systems and Firmware

C is also widely associated with embedded systems.

An embedded system is a computer built into a larger device.

It could be inside:

a vehicle
a router
a medical device
an industrial machine
a smart appliance
a controller
an electronic product

In such systems, the software may need to work with limited memory and processing resources and interact directly with hardware.

That makes C a practical choice for many embedded applications.

Compilers and Development Tools

A compiler is software that helps turn source code into a form that can be executed.

C itself has also played an important role in the development of compilers, tools and software libraries.

This creates an interesting relationship: C is not only used to create applications; it can also be used to create some of the tools that help programmers build software.

Libraries and Software Components

Not every piece of software is a complete application.

Sometimes developers build a library — a collection of reusable code that other programs can use.

C is widely used for such low-level and reusable components because its code can be designed to work efficiently across different systems.

The C standard itself is designed with portability in mind, which is one reason the language has remained useful across different computing environments.

Networking and Performance-Sensitive Software

C can also be found in software where performance and resource usage are important.

Networking components, system utilities and other performance-sensitive parts of software can benefit from the control that C provides.

However, it is important not to misunderstand this point.

C is not automatically the right choice for every fast program.

Modern software uses many different languages, and the right choice depends on the problem, platform, development requirements and team.

C remains valuable because there are still many situations where its particular combination of efficiency, portability and control is useful.

What Can We Build in This Series?

Learning a programming language becomes much more meaningful when we actually use it.

That is why this series will not stop at explaining syntax.

As we move forward, we will start with small programs and gradually increase the complexity.

We will work with things such as:

basic calculations
input and output
decision-making programs
loops
arrays
strings
functions
pointers
memory
structures
files
practical utilities
larger programs
real-world projects

The goal is not to memorise C commands.

The goal is to understand how to think in C and how to turn that thinking into working software.

As the series progresses, the projects will become more practical. The final project will also be connected with TheTejProjects, where the project can be presented as a real build rather than remaining only as an exercise inside a tutorial.

Why Is C Still Important Today?

This is probably the question many beginners have.

C is not a new language. It has been around since the early 1970s.

So why should someone learning programming today still care about it?

The answer is not simply that C is old or famous.

C has remained relevant because the problems it is good at solving have not disappeared.

Computers still need operating systems.
Devices still need firmware.
Processors still need software.
Memory still needs to be managed.
Hardware still needs software to communicate with it.
Performance still matters.
And developers still need languages that can produce efficient programs while giving them a clear understanding of what the machine is doing.

The Linux kernel is one current example of this continued role. Its documentation describes the kernel as being written in C and explains that a strong understanding of C is required for kernel development.

C is also still an internationally standardized language. The current C standard, ISO/IEC 9899:2024, was published in October 2024.

So C is not simply a historical language that is preserved for educational reasons.

It is still an actively standardized programming language with real-world uses.

What Makes C Powerful?

C's power comes from its balance.

It gives us normal programming features that allow us to build logical programs, but it also lets us work much closer to memory and system resources when the situation requires it.

This means a programmer can start with something simple:

int a = 10;
int b = 20;

and eventually learn concepts that go much deeper:

Variables
   ↓
Data
   ↓
Functions
   ↓
Memory
   ↓
Pointers
   ↓
Files
   ↓
System interaction
   ↓
Real software

That progression is one of the most valuable things about learning C.

You do not simply learn another programming syntax.

You begin to understand what a program is doing with its data and resources.

And when we eventually reach pointers and memory, many concepts that initially seem mysterious in programming start becoming much easier to understand.

Is C a High-Level or Low-Level Language?

You will often hear people call C a high-level, low-level, or even middle-level language.

This can be confusing for beginners.

The simplest accurate explanation is this:

C is generally classified as a high-level programming language, but it provides capabilities that allow programmers to work much closer to the machine.

The term “middle-level language” is often used in educational material to describe this balance, but it is better understood as a descriptive term rather than an official classification of the language.

In practical terms, you can think of C like this:

More abstract
     ↑
High-level application languages
     |
     |      C
     |
     ↓
Machine / hardware level

C sits in an interesting position because it lets us write understandable program logic while still giving us much more control over memory and system behaviour than many higher-level languages.

We will understand this much better when we start working with pointers, memory and data representation.

C Is More Than Just Syntax

When beginners start learning C, it is easy to focus only on things like:

printf();
scanf();
if();
for();
while();

These are important, but they are only the beginning.

The real value of learning C comes from understanding why these things exist and how they work together.

For example:
A variable is not just a name with a value.
An array is not just a list.
A pointer is not just another data type.
A function is not just a block of code.
A file is not just something we open and close.

As we move through this series, we will gradually understand what is happening behind these concepts instead of simply memorising their syntax.

That is the approach we will follow throughout this master series.

What You Will Learn in This C Programming Series

This series is designed to move from the first principles of C toward practical software development.

Part 01 — The Story Behind C
We explored how C developed and how its early relationship with Unix shaped the language.

Part 02 — Understanding C
This is where we are now: what C is, where it is used, what it can build, why it still matters and what makes it different.

Part 03 — Writing Your First C Program
We will set up the environment, understand the basic structure of a C program, compile it and run our first program.

Part 04 — Variables, Data Types and Input/Output
We will start working with real data and learn how a C program receives, stores and processes information.

Part 05 — Building Logic
We will move into conditions, decisions and loops and start solving more meaningful programming problems.

Part 06 — Arrays, Strings and Functions
We will learn how to organise data and divide larger programs into reusable parts.

Part 07 — Pointers and Memory
This is where C becomes much more interesting. We will understand memory, addresses and pointers through practical examples.

Part 08 — Structures and Files
We will learn how to organise more complex data and work with information stored outside the program.

Part 09 — Building Real Projects
The concepts learned throughout the series will come together in practical software projects.

Part 10 — The Final Project
The series will end with a larger project that brings the major concepts together. The project will also be presented through TheTejProjects with its related resources and source code.

What Should You Expect From This Series?

The goal of this series is not to make you memorise hundreds of C keywords.

It is to take you from:

“I have never written C before.”

to:

“I understand what my C program is doing, why it works, and how to build something with it.”

We will therefore learn through a combination of explanation, code, experimentation and projects.

Some concepts will be simple.
Some will take more time.
And some, especially memory and pointers, will require us to slow down and understand what is actually happening.

That is completely normal.

Programming is not about understanding everything in one sitting. It is about building one concept on top of another until the bigger picture becomes clear.

Final Thoughts

C is not simply a language from the past that students learn because it appears in a computer science syllabus.

It is a general-purpose language that can be used to build executable software, work with data, interact closely with computer resources and create software for systems where efficiency and control matter.

Its history explains where it came from. Its design explains why it became important. And its continued use shows why it has not simply disappeared with the arrival of newer languages.

But knowing these facts is only the beginning.

The real understanding of C will start when we write our first program.

In the next part, we will stop talking about C only as a concept and actually start using it.

We will set up the required tools, understand what happens when C code is compiled, look at the basic structure of a C program and finally write our first program.

Part 03 — Starting C: Setup, Compilation and Your First Program.

Sources

ISO/IEC 9899:2024 — International Standard for the C programming language.

Linux Kernel Documentation — Programming Language.

Linux Kernel Development HOWTO — C and kernel development.

Dennis Ritchie, The Development of the C Language — Bell Labs.