Questions: Primitive Data Types

Question 1

A programmer writes `result = 7 / 2` in a language where both 7 and 2 are integers. What is the value of `result`?

• A. 3.5
• B. 3
• C. 4
• D. This is a syntax error — you cannot divide two integers

Answer: (B)

Integer division truncates the fractional part rather than rounding, so 7/2 = 3. To get 3.5, at least one operand must be a float (e.g., 7.0/2 or float(7)/2). This surprises many beginners who assume division always produces a decimal result — option 0 is the most tempting wrong answer because it's mathematically correct for real-number division, but type-constrained integer division is a different operation.

Question 2

A language that infers a variable's type from the assigned value and checks type rules when operations execute is called:

• A. Statically typed
• B. Dynamically typed
• C. Weakly typed
• D. Polymorphic

Answer: (B)

Dynamically typed languages (like Python) infer type from value and check rules at runtime. Statically typed languages (like Java or C) require explicit declarations and catch type errors before the program runs. 'Weakly typed' describes how strictly type conversions are enforced — a separate concept — and polymorphism describes how operations can work on multiple types, which is unrelated to when type-checking occurs.

Question 3

In most programming languages, the expression `0.1 + 0.2` evaluates to exactly `0.3`.

• T. True
• F. False

Answer: False

This is false. Floating-point numbers are stored in binary, and most decimal fractions cannot be represented exactly. `0.1 + 0.2` produces `0.30000000000000004` in most languages — not a bug, but a fundamental limitation of binary floating-point representation. It matters in practice: comparing floats for exact equality (`x == 0.3`) is unreliable; you must use an epsilon comparison or a decimal library instead.

Question 4

Booleans in modern typed languages are simply a special name for the integers 0 and 1.

• T. True
• F. False

Answer: False

While some older languages (like C) used integers for boolean values, modern type systems treat booleans as a distinct type with a distinct semantic role: representing truth or falsity, not quantity. The confusion conflates implementation detail with conceptual meaning. A boolean answers 'is this condition true?' — a fundamentally different question from 'how many?' Using integers as booleans obscures intent and invites errors like using 2 (truthy in most languages) where only 0 or 1 is expected.

Question 5

Why does the type of a value matter in programming, beyond just labeling it? Give a concrete example of a type affecting what an operation produces.

Model answer: Type determines which operations are valid and what they produce. For example, `5 + 3` on integers yields 8 (arithmetic sum), while `'5' + '3'` on strings yields '53' (concatenation) in many languages — the same operator symbol performs fundamentally different actions depending on operand types. Without types, the computer cannot know which behavior is intended, and silent type confusion causes bugs that are difficult to trace.

This is the core insight: types are not labels, they are specifications of behavior. Integer division vs. float division, string concatenation vs. numeric addition — these distinctions explain entire categories of beginner bugs. Understanding types is what allows you to predict, rather than guess, what a program will do.