OSAT Computer Science (OK181) common mistakes
OSAT Computer Science (OK181) · Understand the traps and how to avoid them.
When tracing a loop or recursive function, writing only the final output and skipping the intermediate variable states, so an off-by-one error in the loop bound or base case goes undetected.
Candidates who are fluent programmers often 'run' short code mentally and trust the result; under time pressure they skip the state table that would expose the boundary condition.
What to do instead
For any loop or recursion on the exam, draw a trace table with one column per variable and one row per iteration/call, and always test the boundary (first iteration, last iteration, empty input, base case). Verify the loop executes n times versus n-1 times explicitly.
Confusing average-case and worst-case complexity, for example labeling quicksort as O(n log n) without qualification or claiming hash table lookup is O(1) in the worst case.
Textbook summaries often state only the average case, and candidates memorize the headline number without the conditions that produce the worst case (sorted pivot input, hash collisions).
What to do instead
For each algorithm, memorize a three-part fact: best, average, and worst case, plus the input condition that triggers the worst case. Practice stating quicksort as O(n log n) average / O(n^2) worst, and hash lookup as O(1) average / O(n) worst.
Treating Big-O as a measure of exact runtime or comparing algorithms by counting statements instead of identifying the dominant growth term.
Candidates conflate empirical timing with asymptotic analysis, and forget to drop constants and lower-order terms when simplifying expressions like 3n^2 + 5n + 7.
What to do instead
Practice simplifying a dozen complexity expressions to their dominant term, and articulate in one sentence why constants are dropped (asymptotic behavior as n grows). Distinguish Big-O (upper bound) from Big-Theta (tight bound) explicitly.
Mixing up the layers of the TCP/IP and OSI models, for example placing IP at the transport layer or assigning MAC addresses to the network layer.
The two models use overlapping terminology and different layer counts, and candidates memorize layer names without anchoring each to a concrete protocol or device.
What to do instead
Build a one-page table mapping each layer to its protocols (Ethernet, IP, TCP/UDP, HTTP/DNS) and its device or address type (MAC, IP, port). When a question names a protocol, immediately name its layer and address type before reading the answers.
Selecting a database join or normalization answer based on intuition rather than checking which table's rows must be preserved, producing an inner join where a left join is required or vice versa.
Candidates focus on the ON condition and forget that join type determines row preservation; similarly they memorize normal-form definitions without applying the functional-dependency test.
What to do instead
For join questions, first write down which rows must appear in the result (all left rows? only matches?). For normalization, list the functional dependencies and test each candidate key against 2NF (partial dependency) and 3NF (transitive dependency) explicitly.
Describing a security control by its name only, for example answering 'use encryption' or 'use a firewall' without naming what threat it mitigates or which layer it operates at.
Candidates memorize vocabulary lists and answer with the term that sounds most secure rather than reasoning about the specific attack described in the scenario.
What to do instead
For each security scenario, identify the asset, the threat, and the attack vector first, then choose the control that addresses that vector. Practice pairing controls with threats (SQL injection to parameterized queries, XSS to output encoding, MITM to TLS).
Answering digital citizenship or ethics items with a personal opinion or a generic 'be responsible' statement instead of applying a named ethical framework or legal principle.
These items feel subjective, so candidates answer from intuition and miss the specific principle (privacy, intellectual property, accessibility, acceptable use) the item is testing.
What to do instead
Learn the standard lenses (utilitarian, deontological, virtue) plus key concepts: fair use, FERPA, COPPA, ADA/Section 508 accessibility, and the Digital Millennium Copyright Act. For each scenario, name the principle and apply it in one sentence before choosing.
Designing an assessment or lesson activity that names a tool or technology but does not state the learning objective, the evidence of learning, or how the objective is measured.
Candidates with strong technical backgrounds default to describing what students will do with the technology rather than what they will learn and how it will be assessed.
What to do instead
Use a fixed template for every instructional item: objective (observable verb), activity, evidence/artifact, and assessment method. Ensure the objective uses a measurable verb from Bloom's taxonomy and that the assessment directly matches it.
Confusing formative and summative assessment, or proposing assessment only at the end of a unit when the item asks how to support learning during instruction.
The terms are taught early and treated as settled knowledge, so candidates stop checking the purpose (feedback during learning versus judgment of learning) when reading a scenario.
What to do instead
Anchor the distinction on timing and purpose: formative is during instruction to adjust teaching; summative is after to judge achievement. When an item mentions monitoring progress, giving feedback, or adjusting instruction, select a formative approach.
Converting between binary, decimal, and hexadecimal by guessing or by pattern-matching the answer choices instead of performing the positional-value computation.
Candidates rely on calculator habits or memorized conversions for common values and have no reliable method for unfamiliar numbers under exam conditions.
What to do instead
Practice the group-of-four method: convert binary to hex by grouping bits in fours from the right, and to decimal by summing powers of two. Do ten conversions of arbitrary values without a calculator and verify each by converting back.