Introduction to Algorithms, Programming, and Compilers

A logic error occurs when the program runs without crashing but produces the wrong result. This statement follows Java's grammar and completes, so the problem is in what it calculates, not in whether it can run.

• A is not correct: a syntax error prevents compilation, and nothing here breaks Java's grammar.
• C is not correct: a run-time error interrupts a program during execution; this statement is not interrupted.
• D is not correct: the statement does not print 25.12, so there is an error.

A compiler message usually contains a description of the error, the line where the compiler noticed it, and sometimes a caret symbol pointing near the problem. Read the whole message before you touch anything: the caret marks where the compiler gave up, which is not always where you went wrong. Here the description names an unclosed string literal, so closing the string is the first step.

• A is not correct: the message describes an unclosed string literal, not a class-name problem.
• B is not correct: removing the call deletes the statement instead of correcting the unclosed string literal.
• D is not correct: debugging should be a controlled investigation, not a series of random changes.

A run-time error occurs when a program starts but fails during execution. Nothing here breaks Java's grammar, so the compiler can create the bytecode; the failure appears when the division is evaluated.

• A is not correct: a syntax error is an error that breaks Java's grammar and prevents compilation. Nothing in this statement breaks Java's grammar, so the compiler can create the bytecode; the failure appears only when the JVM evaluates the division.
• C is not correct: Java cannot evaluate integer division by zero, so no value is printed.
• D is not correct: a logic error means the program runs without crashing but produces the wrong result; here execution is interrupted.

Identifiers are names chosen for parts of the program. Both declarations are legal when each is stored in the matching file, but they name two different classes.

• A is not correct: Java is case-sensitive, so changing a letter's case changes the identifier. ScoreBoard and scoreBoard differ by one letter's case, and that is enough to make them two separate names.
• B is not correct: beginning with an uppercase letter is the standard naming convention for Java class names, not a rule that makes the other declaration illegal. Both declarations are legal when each is stored in the matching file.
• D is not correct: a run-time error interrupts a program during execution; a declaration stored in its matching file is legal.

When a complete Java program runs, execution begins in the main method. The statements inside main are the statements that run first.

• A is not correct: the compiler translates source code into bytecode, not the main method.
• B is not correct: variables may be declared in many different scopes, not stored by main as a special container.
• C is not correct: syntax errors are detected by the compiler; main does not prevent them.

During compilation, Java source code is checked for syntax errors. If compilation succeeds, the source code is translated into bytecode that can be run by the Java Virtual Machine.

• A is not correct: running a Java program happens in two stages. First the compiler checks the source code and prepares it; then the JVM runs the prepared code. This choice describes the second stage, not compilation.
• B is not correct: the compiler does not test the program with sample input or guarantee that the logic is correct.
• C is not correct: the source file already has to match the public class: because the public class is named MyFirstClass, the source file must be named MyFirstClass.java. Compilation does not change that name; it translates the source code into bytecode.

An algorithm does not have to be written in Java. It can be described in plain English, pseudocode, diagrams, or numbered steps, as long as the steps are clear enough to follow.

• B is not correct: a Java program may implement an algorithm, but the algorithm itself is not necessarily a Java program.
• C is not correct: a compiler message reports a problem in the source code. It usually contains a description of the error, the line where the compiler noticed it, and sometimes a caret symbol pointing near the problem. That is evidence for debugging, not a procedure for solving a problem.
• D is not correct: compilation produces bytecode, an instruction format that the JVM can understand. An algorithm is an idea, not a programming language, and it can be described before any code is written.

Pseudocode is language-independent. Its purpose is to describe the intended steps clearly without requiring exact Java syntax.

• A is not correct: pseudocode is a compact, language-independent way to write an algorithm. It uses familiar words to express the intended actions without requiring the punctuation or exact keywords of a programming language.
• B is not correct: pseudocode is a way to plan logic before writing Java syntax, so it does its work before compilation rather than after it.
• D is not correct: bytecode is the instruction format the compiler produces for the JVM. Pseudocode is written for people, so that the actions and their order are clear enough that the plan can later be translated into code.

"Ready!" is a String literal. The quotation marks show where the text begins and ends; they are part of the source code but are not printed as part of the output.

• B is not correct: MyFirstClass is an identifier, a name chosen for part of the program.
• C is not correct: main is an identifier, not a value written directly in the source code.
• D is not correct: public is a reserved keyword; Java assigns it a fixed meaning.

An algorithm is an ordered procedure. Moving a calculation, decision, or output step can change the result or make the procedure invalid.

• B is not correct: an algorithm is an idea, not a programming language. You can describe one in everyday language, with a diagram, as numbered steps, or in pseudocode.
• C is not correct: a compiler follows the written program; it does not repair the algorithm's order.
• D is not correct: sequencing means the instructions are arranged in a deliberate order. An algorithm is read from top to bottom, and each step is carried out in the order shown.

The source file remains a .java file. Successful compilation creates a separate compiled .class file containing bytecode for the JVM to run.

• A is not correct: the compiler works in the other direction: it checks the source code and translates it into bytecode. Pseudocode is a way to plan logic before writing Java syntax, so it is not something the two stages of running a program produce.
• C is not correct: compilation creates a new class file rather than renaming the source file.
• D is not correct: the JVM executes the program; it does not guarantee that its logic is correct.