Introduction to Programming Fundamentals

Programming fundamentals are the basic concepts used to write, organize, test, and understand computer programs. Before a programmer studies object-oriented programming, database programming, web development, artificial intelligence, or systems programming, the programmer must first understand how instructions are written and how those instructions are executed by a computer.

This module introduces the foundation of structured programming. Structured programming is a disciplined method of writing programs by using clear control flow, organized blocks of code, functions, and predictable logic. The goal is not merely to make a program run. The goal is to make the program understandable, testable, maintainable, and easier to modify.

A computer program is a set of instructions written in a programming language. These instructions tell the computer what data to use, what calculations to perform, what decisions to make, and what output to produce. Although programming languages differ in syntax, most high-level languages share common ideas. Variables, expressions, operators, conditions, loops, functions, arrays, and algorithms appear in many languages, including C, C++, Java, C#, Python, JavaScript, PHP, and Perl.

This course uses Java examples to practice programming concepts, but the purpose of the module is broader than learning one language. The concepts introduced here apply across many languages. When you understand sequence, selection, iteration, modularity, and data representation, you are better prepared to study Java, C++, C, Python, or another high-level programming language.

Programming is a form of problem solving. A programmer starts with a problem, analyzes the required input and output, designs a sequence of steps, and then translates those steps into source code. The computer does not understand vague instructions. It follows precise statements according to the rules of the programming language and the runtime environment.

For this reason, beginning programmers must learn how to think in a structured way. A program should not be a random collection of statements. It should have a clear purpose, a logical order, and a design that allows another programmer to read it later. Good programming fundamentals reduce errors because the programmer can reason about what the code is supposed to do.

These fundamentals also support later study in object-oriented programming. In C++ and Java, classes, objects, constructors, methods, inheritance, and polymorphism build on basic programming concepts. A method still contains statements. A class still uses variables and expressions. An object-oriented program still requires decision-making, loops, and algorithms. Structured programming remains important even when the larger design uses object-oriented techniques.

At a basic level, a computer program accepts data, processes that data, and produces a result. The data may come from the keyboard, a file, a database, a web form, a network service, or another program. The processing may include arithmetic, comparison, string manipulation, searching, sorting, validation, or communication with other systems.

For example, a simple payroll program might read the number of hours worked and the hourly rate. It then multiplies those values to calculate gross pay. A student grade program might read test scores, compute an average, and display a letter grade. A sorting program might read a list of values and rearrange them from smallest to largest.

These examples differ in purpose, but they use the same underlying ideas: data storage, expressions, operators, control flow, and algorithms. This module introduces those building blocks so that later programming topics have a solid foundation.

Structured programming is a programming approach that organizes logic into well-defined structures. It avoids uncontrolled jumps in program flow and encourages code that can be followed from top to bottom. The most important control structures are sequence, selection, and iteration. These structures are sufficient to express a wide range of algorithms.

Structured programming also encourages decomposition. A large problem is broken into smaller tasks. Each task can be implemented as a function, method, or procedure. This approach improves readability because the program is divided into named units of work. It also improves maintainability because a programmer can modify one unit without rewriting the entire program.

Sequence means that statements execute in the order in which they appear. The first statement runs, then the second statement runs, and so on. This is the simplest form of control flow. Even complex programs depend on sequences of statements to assign values, perform calculations, and display results.

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

System.out.println(sum);

In this example, the program assigns values to a and b, calculates their sum, and then displays the result. The order matters. The variable sum cannot be printed correctly until after it has been calculated.

Selection means that a program chooses between different paths of execution. A condition is evaluated, and the result determines which block of code will run. Selection is commonly implemented with if, else, and switch statements.

int score = 75;

if (score >= 50) {
    System.out.println("Pass");
} else {
    System.out.println("Fail");
}

The condition score >= 50 evaluates to either true or false. If the condition is true, the program prints Pass. If the condition is false, the program prints Fail. Selection allows a program to react to different data values.

Decision-making is essential in real programs. A banking program must determine whether an account has enough funds. A login system must determine whether a password is valid. A shipping application must determine which rate applies to a package. In each case, the program uses conditional logic.

Iteration means repeating a block of code. Loops are used when a task must be performed more than once. Most high-level languages provide loop structures such as for, while, and do-while.

for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

This loop prints the values 0 through 4. The loop begins with i equal to 0. It continues as long as i < 5 is true. After each repetition, i is increased by 1.

Loops are used to process arrays, read records, search data, validate input, and repeat calculations. Without iteration, programmers would have to write the same statements over and over again. Loops make programs shorter, clearer, and more flexible.

Modularity means dividing a program into smaller units. In procedural programming, these units are often called functions or procedures. In Java and C++, they may be implemented as methods that belong to classes. The purpose is the same: place a related group of statements into a named unit that performs one task.

public static int add(int a, int b) {
    return a + b;
}

public static void main(String[] args) {
    int sum = add(5, 10);
    System.out.println(sum);
}

The add method receives two integer values and returns their sum. The main method calls add instead of repeating the addition logic inline. This makes the code easier to reuse and easier to test.

Modularity becomes increasingly important as programs grow. A small program may fit on one screen, but larger systems require organization. A payroll system, inventory system, web application, or database application may contain many thousands of lines of code. Without modular design, such systems become difficult to debug and maintain.

A block is a group of statements enclosed by braces. Blocks help define the structure of a program. They also control the scope of variables. Scope refers to the region of the program in which a variable can be accessed.

{
    int x = 10;
    System.out.println(x);
}

In this example, the variable x is declared inside the block. It exists only within that block. Code outside the block cannot use x. Local scope reduces accidental interference between different parts of a program.

Scope is especially important when programs use nested blocks, loops, methods, and classes. A programmer should know where each variable is declared, where it can be used, and when its value is no longer available.

Programs operate on data. Before a program can calculate, compare, or display information, the data must be represented in memory. Computers store data using binary values, but programming languages provide higher-level data types so programmers can work with meaningful values.

Common primitive data types include integers, floating-point numbers, characters, and Boolean values. Strings are used to represent text. Arrays store multiple values under one name. These data structures allow programs to represent real information such as names, ages, prices, scores, dates, and identifiers.

Understanding data representation helps a programmer avoid common errors. For example, integer division may discard a fractional part. A character is not the same as a string. A number stored as text cannot be used in arithmetic until it is converted. These details are part of programming fundamentals.

An expression is a combination of values, variables, operators, and method calls that produces a result. Operators perform actions such as addition, subtraction, multiplication, division, comparison, and logical evaluation.

int quantity = 4;
double price = 19.95;
double total = quantity * price;

The expression quantity * price multiplies the number of items by the price of each item. The result is assigned to total. Expressions are used throughout programs to calculate values and make decisions.

Operator precedence determines the order in which operations are performed. For example, multiplication is evaluated before addition unless parentheses change the order. A programmer must understand precedence to avoid writing expressions that produce unexpected results.

An algorithm is a step-by-step procedure for solving a problem. A program is often an implementation of one or more algorithms. Algorithms may be simple, such as calculating an average, or more complex, such as sorting a list of values.

A sorting algorithm rearranges data into a defined order. A search algorithm finds a desired value. A validation algorithm checks whether input satisfies a rule. The programmer must understand the problem before selecting or designing the algorithm.

Structured programming helps express algorithms clearly. Sequence determines the order of steps. Selection handles decisions. Iteration handles repetition. Modularity divides the algorithm into smaller tasks.

After completing this module, you should be able to:

1. Explain what a computer program is and how it executes instructions.
2. Describe how programs store and manipulate numbers and text.
3. Use sequence, selection, and iteration to control program flow.
4. Understand how functions or methods support modular programming.
5. Use primitive data types in Java programs.
6. Apply arithmetic, relational, logical, increment, decrement, and remainder operators.
7. Understand numeric promotion, truncation, conversion, casting, and operator precedence.
8. Use conditional statements and loops to implement structured logic.
9. Use class methods to organize reusable program behavior.
10. Use arrays to store and process groups of related values.
11. Implement basic algorithms such as searching and sorting.

These goals prepare you for later modules that study programming languages in more detail. They also prepare you for object-oriented programming, where structured logic is placed inside classes and methods.

Although this module uses Java for practice, the principles are not limited to Java. C, C++, C#, Python, JavaScript, PHP, and Perl all use variables, expressions, decisions, loops, and functions or methods. The syntax differs, but the underlying logic is similar.

C is often used to teach low-level programming concepts and memory-oriented thinking. C++ extends C-style programming with object-oriented features, templates, and modern language facilities. Java emphasizes portability, strong typing, class-based design, and managed execution through the Java Virtual Machine. Python emphasizes readability and rapid development. JavaScript is central to browser-based programming and modern web applications.

Learning programming fundamentals gives you a transferable skill set. Once you understand the basic structures, learning another language becomes easier because you can compare the new syntax to concepts you already know.

Structured programming and object-oriented programming are not enemies. Object-oriented programming builds on structured programming. A method in a class may contain sequence, selection, and iteration. An object may store data in fields and expose behavior through methods. A well-designed class still depends on clear control flow and understandable logic.

For example, a class that models a bank account may include methods for depositing money, withdrawing money, and checking the balance. Each method uses structured logic internally. A withdrawal method may use selection to determine whether enough funds are available. It may use arithmetic to subtract the withdrawal amount. It may return a value indicating whether the operation succeeded.

This is why programming fundamentals should be studied before advanced object modeling. Without structured logic, object-oriented code can still become confusing. Good class design requires good method design, and good method design requires a strong foundation in programming fundamentals.

This lesson introduced the purpose of the programming fundamentals module. A computer program is a precise set of instructions that operates on data and produces a result. Structured programming organizes those instructions using sequence, selection, iteration, modularity, and block structure.

These concepts are essential because they appear in almost every high-level programming language. They also support later study in Java, C++, object-oriented design, algorithms, and software engineering. By mastering programming fundamentals, you build the mental model needed to design programs that are readable, reliable, and maintainable.

In the next lesson, you will study the prerequisites for this course and prepare to apply these concepts in actual programming exercises.