Introduction

Before writing any code, programmers must understand what they're creating and how their programs come to life. Topic 1.1 introduces the fundamental concepts of algorithms, the compilation process, and the types of errors you'll encounter in programming.

An algorithm is a step-by-step process for solving a problem or completing a task. Every program you write is essentially an algorithm translated into a programming language. Understanding how compilers check your code and identifying different error types are essential skills that will serve you throughout the AP Computer Science A course and beyond.

Algorithms and Sequencing

What is an Algorithm?

An algorithm defines a step-by-step process to follow when completing a task or solving a problem. Algorithms can be represented using written language, diagrams, or pseudocode before being implemented in a programming language.

Everyday Algorithm Example: Making a Sandwich

This simple example demonstrates the key characteristic of algorithms: they provide clear, ordered instructions.

Sequencing

Sequencing defines the order in which steps in a process are completed. Steps in an algorithm are completed one at a time, in the specified order. The sequence matters—spreading jelly before opening the jar would cause problems!

Simple Programming Algorithm Example:

Calculate the area of a rectangle:

The order is crucial: you must have both measurements before calculating the area.

The Compilation and Execution Process

Text Editors vs. Integrated Development Environments (IDEs)

Code can be written in any text editor (like Notepad or TextEdit), but programmers typically use an Integrated Development Environment (IDE) because it provides specialized tools:

Popular Java IDEs include Eclipse, IntelliJ IDEA, and BlueJ.

How Compilers Work

A compiler is a program that translates your human-readable Java code into machine-readable bytecode that the computer can execute. The compilation process involves several important steps:

Critical Point: A compiler checks code for certain errors and will refuse to compile if errors are detected. You must fix all compiler-detected errors before your program can run.

Types of Programming Errors

Understanding error types is essential for debugging. Each error type is detected at different stages and requires different approaches to fix.

Syntax Errors

A syntax error is a mistake in the program where the rules of the programming language are not followed. These errors are detected by the compiler before the program runs.

Common Syntax Errors:

// Missing semicolon
int x = 5

// Misspelled keyword
publc class Test { }

// Mismatched parentheses
System.out.println("Hello";

// Incorrect variable declaration
int 2ndNumber = 10;

Compiler messages for syntax errors typically include:

Key characteristic: Syntax errors prevent compilation—the program cannot run until they're fixed.

Logic Errors

A logic error is a mistake in the algorithm or program that causes it to behave incorrectly or unexpectedly. These errors are detected by testing the program with specific data to see if it produces the expected outcome.

Logic Error Examples:

// Calculating average incorrectly
int sum = a + b + c;
int average = sum / 2;  // Should divide by 3!

// Wrong comparison operator
if (score > 90) 
{
    System.out.println("You failed");  // Should be <, not >
}

// Off-by-one error in a calculation
int finalPrice = price + tax - 1;  // Why subtract 1?

Key characteristics:

Debugging logic errors requires:

Run-Time Errors

A run-time error is a mistake in the program that occurs during the execution of a program. Run-time errors typically cause the program to terminate abnormally (crash).

Run-Time Error Examples:

// Array index out of bounds
int[] numbers = {1, 2, 3};
System.out.println(numbers[5]);  // Only indices 0-2 exist

// Null pointer
String text = null;
System.out.println(text.length());  // Can't call method on null

// Division by zero
int a = 10;
int b = 0;
int result = a / b;  // Cannot divide by zero

Key characteristics:

Exceptions

An exception is a type of run-time error that occurs as a result of an unexpected error that was not detected by the compiler. It interrupts the normal flow of the program's execution.

Common Exception Examples:

// ArithmeticException
int result = 10 / 0;

// NullPointerException
String s = null;
int len = s.length();

// StringIndexOutOfBoundsException
String word = "hello";
char c = word.charAt(10);

// NumberFormatException
int num = Integer.parseInt("abc");

Exception messages include:

Note: While all exceptions are run-time errors, not all run-time errors are exceptions. The term "exception" specifically refers to errors that Java's exception handling system can catch and manage.

Error Type Comparison

Common Mistakes

Mistake 1: Confusing syntax errors with logic errors

// This is a SYNTAX error (won't compile)
int x = 5

// This is a LOGIC error (compiles but wrong answer)
int average = (a + b) / 3;  // Should divide by 2

Remember: If the compiler complains, it's a syntax error. If the output is wrong, it's likely a logic error.

Mistake 2: Thinking all run-time errors are exceptions

While exceptions are a type of run-time error, the terms are not interchangeable. Exceptions are specific error objects that Java creates when certain problems occur.

Mistake 3: Not understanding that sequencing matters

// WRONG order
int result = a / b;
int b = 5;  // b used before it's defined!

// CORRECT order
int b = 5;
int result = a / b;

Variables must be declared and initialized before they can be used.

Mistake 4: Ignoring compiler error messages

Compiler messages tell you exactly what's wrong and where. Reading them carefully saves time:

Test.java:5: error: ';' expected
int x = 10
         ^

This message clearly indicates a missing semicolon at line 5.

Practice Problems