1.1 Why Programming? Why Java?

TLDR

In AP Computer Science A, an algorithm is a step-by-step process that runs in a set order, and Java code becomes a runnable program through compilation. The compiler catches some errors before the program runs, while other problems only show up while it runs or when the output is just wrong. Knowing the difference between syntax, logic, and run-time errors helps you read code and fix it faster.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

What Do You Learn First in AP Computer Science A?

AP CSA starts with algorithms, sequencing, and the path from written Java code to a running program. You need to recognize how ordered steps become code and how different error types affect a program: syntax errors stop compilation, run-time errors happen during execution, and logic errors produce the wrong result even when the code runs.

Why This Matters for the AP Computer Science A Exam

This topic builds the base for everything else in the course. Before you write loops or design classes, you need to think in clear, ordered steps and understand how code goes from text you type to a program that runs.

On the multiple-choice section, you will trace short code segments and decide what they output or why they fail. Recognizing whether something is a syntax error, a logic error, or a run-time error is a skill those questions test directly. The free-response section asks you to write methods that carry out algorithms, so the habit of planning ordered steps before coding pays off there too.

Key Takeaways

• An algorithm is a step-by-step process, and sequencing means each step finishes before the next one starts.
• You can represent an algorithm with written language or a diagram before writing any Java.
• Code can be written in any text editor, but an IDE adds tools to write, compile, and run code in one place.
• A compiler checks for some errors, and those errors must be fixed before the program will run.
• Syntax errors break the rules of the language and are caught by the compiler.
• Logic errors let the program run but produce wrong results, and you find them by testing with specific inputs.
• A run-time error happens during execution and usually stops the program; an exception is a run-time error the compiler did not catch.

Algorithms in Everyday Life

An algorithm is a step-by-step process to solve a problem or complete a task. Making a sandwich is an algorithm: you follow specific steps in a specific order. You cannot spread peanut butter before you take out the bread.

That ordering is called sequencing. Steps run one at a time, and each step completes before the next begins. Computers process instructions the same way, so sequencing is a core idea in programming.

You can write an algorithm in plain language or draw it as a diagram before you touch any code. Planning the steps first usually makes the actual coding faster and more accurate.

A useful algorithm has:

1. A clear starting point
2. Steps that run in order
3. Each step finishing before the next begins
4. A clear ending point
5. Steps that work for the general case, not just one specific input

From Code to a Running Program

You write Java in a text file, but the computer cannot run that text directly. A compiler translates your code and checks it for some errors first. If the compiler finds an error it can detect, you have to fix it before the program will run.

Here is the smallest complete Java program. It defines a class, has a main method where the program starts, and prints a line of text with System.out.println:

</>Java
public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, AP Computer Science A!");
    }
}

Inside a program you store values in variables. Each variable has a type and a name, and the assignment operator = puts a value into it. The three primitive types you use most early on are int for integers, double for real numbers, and boolean for true or false:

</>Java
int score = 90;
double average = 88.5;
boolean passed = true;
String name = "Sam";

String is a reference type that holds text, and you can join strings together with +. Reference types like objects are created with the keyword new. You will use these building blocks constantly, so it helps to see what real Java looks like now.

IDEs and Text Editors

You can write code in any plain text editor, but most programmers use an Integrated Development Environment (IDE). An IDE bundles tools to write, compile, and run code in one place.

Common features that make an IDE helpful:

• Syntax highlighting that color-codes your code
• Auto-completion that suggests methods and variables
• Error detection that flags mistakes before you compile
• A built-in way to compile and run your program

These tools are conveniences. The compiler is what actually checks your code for errors that must be fixed before running.

The Types of Errors

Knowing the error types helps you debug quickly and answer exam questions that ask you to spot the problem.

Syntax errors break the rules of the language, like a grammar mistake. The compiler catches these, and the program will not run until you fix them. A missing semicolon, an unmatched brace, or a misspelled keyword all count.

Logic errors let the program compile and run, but it does the wrong thing. Maybe a loop runs one too many times or your math is off. The compiler cannot catch these because the code is technically valid. You find logic errors by testing the program with specific inputs and checking whether the output matches what you expected.

Run-time errors happen while the program is running. The code compiles fine, then something goes wrong during execution and the program usually stops abnormally.

Exceptions are a type of run-time error caused by an unexpected problem the compiler did not detect. An exception interrupts the normal flow of the program.

Code Examples

A Program That Compiles

</>Java
// Compiles and runs successfully
public class SaveMe {
    public static void main(String[] args) {
        System.out.println("Hello, AP CSA!");
    }
}

A Syntax Error

</>Java
// Will not compile: missing semicolon
public class SyntaxError {
    public static void main(String[] args) {
        System.out.println("Oops, no semicolon")  // Missing semicolon
    }
}

The compiler stops here and reports something like error: ';' expected. Nothing runs until you add the semicolon.

A Logic Error

</>Java
// Compiles and runs, but the result is wrong
public class LogicError {
    public static void main(String[] args) {
        int sum = 10 + 20 + 30;
        int average = sum / 4;  // Should divide by 3
        System.out.println("Average: " + average);  // Prints 15, not 20
    }
}

The code is valid Java, so it runs. The output is just wrong because the math is off. You only notice by testing it.

A Run-Time Error

</>Java
// Compiles, but crashes during execution
public class RunTimeError {
    public static void main(String[] args) {
        int[] grades = {90, 85, 92};
        System.out.println(grades[3]);  // Index 3 does not exist
    }
}

Valid indices here are 0, 1, and 2, so reaching for index 3 throws an exception while the program runs.

How to Use This on the AP Computer Science A Exam

Code Tracing

Trace short code segments line by line. Use the values you are given instead of trying to see the answer at a glance. If an array has length 4, your trace should walk through indices 0, 1, 2, and 3. One small mistake early ruins the whole trace, so go slowly.

Identifying Errors

Use a quick decision path. Does the code compile? If not, it is a syntax error. If it compiles, does it always run without stopping? If not, it is a run-time error or exception. If it runs but gives the wrong output, it is a logic error.

Free Response

Free-response code writing asks you to put an algorithm into Java. Plan the ordered steps first, then translate each step into code. Clear sequencing makes your method easier to write and easier for you to check.

Common Trap

Do not assume code that compiles is correct. A program with a logic error runs fine and still produces the wrong answer. Compiling only means the syntax rules were followed, not that the output is right.

Common Misconceptions

• Compiling successfully does not mean the program is correct. Logic errors slip past the compiler completely.
• Syntax errors and run-time errors are not the same. Syntax errors stop the program from compiling; run-time errors happen after it has already started running.
• An algorithm is not only code. You can write or diagram an algorithm in plain language before any Java exists.
• An IDE does not replace the compiler. It adds helpful tools, but the compiler is what checks your code for errors that must be fixed.
• Not every wrong program crashes. Logic errors often run all the way through and just give the wrong result.
• An exception is a kind of run-time error, specifically one the compiler did not catch, not a separate category that happens before the program runs.

Related AP Computer Science A Guides

• 1.2 Variables and Primitive Data Types
• 1.3 Expressions and Assignment Statements
• 1.4 Assignment Statements and Input
• 1.14 Calling a Void Method
• 1.8 Documentation With Comments
• 1.9 Calling a Void Method With Parameters
• 1.6 Compound Assignment Operators
• 1.11 Using the Math Class