Program Coding

1. Translation Method: A Compiler reads and translates the entire source program at once into an executable machine code or bytecode file; An Interpreter translates and executes the source code line-by-line sequentially.
   2. Execution Speed: Compiled programs execute much faster; Interpreted code runs slower because translation occurs during runtime.
   3. Error Reporting: A compiler scans the whole code and generates a complete consolidated list of all syntax errors at the end; An interpreter stops immediately at the first encountered error.
   4. Target File: A compiler creates an independent object file (e.g., .class file in Java); An interpreter does not produce an object file.

• Pre-Increment (++x): The value of $x$ is incremented by 1 first, and then the new updated value is used in the expression (Change-then-Use).
• Post-Increment (x++): The current existing value of $x$ is used in the expression first, and then $x$ is incremented by 1 (Use-then-Change).
• Evaluation of $y = ++x + x++ + 5$ (Initial $x = 10$):
1. ++x: $x$ increments from $10 \to 11$, and returns $11$.
2. x++: Current value of $x$ ($11$) is returned $11$, and then $x$ increments from $11 \to 12$.
3. Calculation: $y = 11 + 11 + 5 = \mathbf{27}$.
• Final values: $y = 27$ and $x = 12$.

• Entry-Controlled Loop (while, for):
1. The loop test condition is evaluated at the beginning (entry point) before executing the loop body.
2. If the condition is False initially, the body of the loop will NOT execute even a single time (0 times).
Example: while (x > 10) { ... }
• Exit-Controlled Loop (do-while):
1. The loop test condition is evaluated at the end (exit point) after executing the loop body.
2. The loop body is guaranteed to execute at least ONCE, even if the condition is completely False from the start!
Example: do { ... } while (x > 10);.

• Purpose of break: The break statement terminates the execution of the switch block and jumps program control immediately to the statement following the closing brace of the switch.
• What Happens if Omitted (Fall-Through):
If break is omitted at the end of a matching case, the program does not stop; it continues executing all subsequent case blocks sequentially—regardless of whether their labels match—until a break or the end of the switch is reached. This unintended bug is called "Fall-Through".

• Implicit Type Conversion (Type Promotion / Widening):
1. Automatically performed by the compiler when converting a smaller data type into a larger, compatible data type without loss of precision.
Example: int a = 10; double b = a; ($10$ is automatically converted to $10.0$).
• Explicit Type Casting (Narrowing):
1. Manually forced by the programmer when converting a larger data type into a smaller data type, where data truncation or loss of precision may occur.
2. Requires the target type enclosed in parentheses.
Example: double x = 9.78; int y = (int)x; ($y$ becomes $9$, fractional $.78$ is truncated).

• Line 1: (a / b) (Integer Division):
Since both a (14) and b (4) are integers, the division operator / discards the fractional part and performs integer division: $14 / 4 = \mathbf{3}$.
Output 1: Result 1: 3
• Line 2: (a % b) (Modulus Remainder Operator):
The % operator calculates the remainder after dividing 14 by 4 ($14 = 4 \times 3 + 2$) $\implies$ remainder is 2.
Output 2: Result 2: 2.

• Syntax:
for (initialization; condition; update) {
// statements to be executed
}
• Three Header Expressions:
1. Initialization: Executed only once when the loop starts; sets the initial value of the loop counter variable (e.g., int i = 1;).
2. Condition: A boolean expression evaluated before each iteration; if True, the body executes; if False, the loop terminates (e.g., i <= 10;).
3. Update (Increment/Decrement): Executed after each iteration body completes; modifies the counter variable (e.g., i++).