Programming is the practice of writing precise instructions that a computer can execute. That sentence is short, but it contains an important idea. A computer does not know what you want. It does not guess, infer, or interpret. It follows instructions precisely. If those instructions are clear and correct, the computer does exactly what you intended. If those instructions contain a mistake, even a small one, the computer does something different from what you intended — or it stops entirely and reports an error.

This chapter opens the door to that practice. Before you begin writing code, you need a clear picture of what programming actually is, what Python is, and how programmers think about the work. You need to understand that programming involves not only writing code, but reading code, tracing execution, testing assumptions, finding errors, and steadily improving programs over time. That is what this chapter provides.

Programming is the practice of writing instructions that a computer can execute.

That sentence is short, but it contains an important idea. A computer does not know what you want. It does not guess, infer, or interpret. It follows instructions precisely. If those instructions are clear and correct, the computer does exactly what you intended. If those instructions contain a mistake, even a small one, the computer does something different from what you intended, or it stops entirely and reports an error.

This precision is both the challenge and the power of programming.

When you write a recipe, you expect a human reader to fill in missing steps, use judgment when something seems off, and adapt to the situation. When you write a program, you cannot rely on any of that. The computer will not add salt because it seems like the right time. It will not notice that you forgot a step. It will follow your instructions exactly as written, in the order you wrote them, no more and no less.

Learning to write instructions precisely is a skill. It takes practice, attention, and patience. But it is not magic. It is not reserved for people with special abilities. It is a craft that rewards careful thinking, systematic testing, and steady improvement.

Programming is also more than just typing code. The full scope of the practice includes:

This textbook will ask you to practice all of these skills in every chapter — not just writing code, but reading it, tracing it, testing it, debugging it, and improving it.

Python is a programming language.

A programming language is a formal system for writing instructions that a computer can process. Programming languages have precise rules for what counts as a valid instruction, what words and symbols mean, and in what order instructions are executed. These rules are called the language's syntax and semantics.

Python was created by Guido van Rossum and first released in 1991. It was designed from the beginning with readability in mind. Van Rossum wanted a language that would look like plain, structured English as much as possible, without sacrificing the power needed to write serious programs.

Here is a short Python program:

Even if you have never written a line of code, you can probably follow what these two lines do. The first line stores the text Alex under the name name. The second line displays a greeting using that stored text. That readability is intentional. Python code, when written well, is often close to a description of what the program does in plain language.

That quality makes Python an excellent first programming language and an excellent language for working through ideas quickly.

Python is now one of the most widely used programming languages in the world. It is used in universities, research labs, companies, government agencies, and independent projects. It is used by beginners learning their first programming concepts and by experienced engineers building complex systems.

Python is a general-purpose language. That means it is not designed for one narrow task. The same language can be used to write a simple grade calculator, a web server, a data analysis pipeline, or a machine learning experiment.

A program is a sequence of instructions.

Instructions are executed one at a time, in order, from top to bottom, unless something tells the program to jump, repeat, or stop. That top-to-bottom execution order is called sequential execution, and it is the default behavior of every Python program you will write in this textbook.

Consider this short program:

When Python runs this program, it executes the first print instruction, then the second, then the third. The output appears in that order. If you swapped two of those lines, the output would change. The order of instructions matters. Programs are not lists of ideas. They are sequences of actions, and the sequence is part of the meaning.

Later in this textbook, you will learn how to make programs more dynamic. You will write instructions that repeat using loops. You will write instructions that skip or choose between paths using conditionals. You will write reusable collections of instructions called functions. But all of those tools build on the foundation of sequential execution. Programs always execute instructions in a particular order, and understanding that order is one of the central skills of reading and debugging code.

The text of a program is called source code.

Source code is what you write in a file or type into an interactive shell. It is human-readable text, written according to the rules of the programming language. Here is a short piece of Python source code:

Source code is not directly executable by a computer's hardware. Computers execute machine code, a very low-level representation of instructions. Something must translate source code into a form the computer can run.

Python uses an interpreter to do this. The Python interpreter reads your source code, understands it according to Python's rules, and executes it one step at a time. When you run a Python program, the interpreter is doing that work.

This means you need two things to run a Python program:

1. The Python interpreter installed on your computer
2. A Python source code file or commands typed into an interactive session

Chapter 2 will walk through setting up Python and running your first programs in detail. For now, the key idea is this: you write text in Python syntax, and the Python interpreter executes that text as a program.

When the interpreter encounters an instruction it cannot understand because of a mistake in your source code, it stops and reports an error message. Here is an example:

Error messages are not failures. They are the interpreter's way of telling you exactly what went wrong and where. Learning to read error messages clearly is one of the most practical skills you will develop in this course. A beginner who panics at error messages stays stuck. A programmer who reads them carefully moves forward.

Many people approach programming by immediately trying to write code. This is understandable. Writing feels productive. But it often leads to confusion, because writing code you do not fully understand is difficult to fix when something goes wrong.

A better habit is to read code before you write it.

Reading code means looking at a program, following its logic carefully, and understanding what it does before you run it. Good programmers read code all the time. They read their own programs to catch errors before running them. They read code written by others to understand how it works. They read documentation and examples to learn new ideas.

This textbook will ask you to read a great deal of code. Each chapter includes activities built around these tasks:

These activities are not warm-ups before the real work. They are the real work. Learning to read code carefully is what makes you a good debugger, a good designer, and a good collaborator. The predict-and-check habit is especially powerful: when your prediction matches the output, you have understood the code. When it does not match, that mismatch is valuable — it tells you exactly where your mental model of Python needs adjustment.

Programming is a tool for solving problems.

A problem, in the programming sense, is a situation where you have information, you want a result, and you need a procedure for producing that result from the information. Programming gives you a way to express that procedure precisely, test it, and run it repeatedly.

Consider a few examples:

In each case, the program is not magic. It is a clear procedure for transforming input into output.

Good programmers do not jump immediately to code when they face a problem. They first understand what the problem is asking. They identify what information they have and what result they need. They think through a procedure in plain language before writing a single line of Python. Then they translate that procedure into code, test it against examples, and refine it when they discover errors.

That practice — understanding the problem before solving it — is called problem decomposition, and it is one of the most important habits you will develop in this textbook.

Every programmer makes errors. This is not a sign of weakness or inexperience. It is the nature of the work. There are three major categories of errors in programming, and each one requires a different approach to find and fix.

Syntax errors occur when your code violates the rules of Python's grammar. The interpreter cannot understand what you wrote. It stops before running anything and tells you where the problem is.

This is a syntax error. The opening parenthesis is not closed. Python reports exactly what is wrong and on which line.

Runtime errors occur when your code is grammatically correct but something goes wrong while the program is running. For example, asking Python to divide by zero, or to open a file that does not exist.

The syntax is fine. Python understands what the code says. But dividing by zero is not defined, and Python stops and reports the problem at the moment it occurs.

Logic errors occur when your code runs without error but produces the wrong result. The program does what you told it to do, but you told it to do the wrong thing. These are the hardest errors to find because Python does not report them. Only careful testing and tracing reveals them.

This runs without error and prints 30.0. But the correct average of 10, 20, and 30 is 20.0. The logic is wrong. Python had no way to know what the programmer intended, only what the programmer wrote.

Python is used in an enormous range of real applications. Understanding this range helps you see why the foundations you build in this textbook matter beyond the classroom.

This textbook does not cover all of these areas. Its goal is to teach you the foundations of Python programming that make all of those applications possible. Before you can analyze data, build a web app, or write a machine learning model, you need to know how to write clean, correct, and organized Python programs. That is what this book teaches.

Programming is a skill, not a subject. The difference matters. You do not learn to program by reading about programming. You learn by writing programs, running them, observing results, fixing errors, and repeating. A textbook can guide your thinking and introduce ideas in a useful sequence, but the skill only develops through practice.

Here are habits that consistently help students learn programming well.