FTCE Computer Science study materials
FTCE Computer Science study resources

FTCE Computer Science common mistakes

FTCE Computer Science · Understand the traps and how to avoid them.

Mistake 1

Treating two's complement as 'flip the bits and add one' only, without being able to explain why the range is asymmetric (−2^(n−1) to 2^(n−1)−1) or converting a negative value back to decimal by hand.

Candidates memorize the negation shortcut but never internalize place value with a negatively weighted most significant bit, so questions about overflow, range, or sign extension expose a shallow understanding.

What to do instead

Practice reconstructing the value from weights: for an 8-bit pattern, compute −128·b7 + 64·b6 + … + 1·b0. Then derive the range yourself from the weights and test edge cases like 1000 0000 and 0111 1111. Do five conversions each direction without the shortcut, then confirm with the shortcut.

Mistake 2

Confusing short-circuit evaluation with full boolean evaluation, or predicting the wrong output when a function call with side effects appears on the right side of && or ||.

Candidates evaluate boolean expressions as pure logic and ignore evaluation order and side effects, a topic that appears in both logic and programming questions.

What to do instead

Write small expressions where the right operand increments a counter, trace them by hand for each operator, then run them. State the rule explicitly: for && the right side is skipped when the left is false; for || it is skipped when the left is true.

Mistake 3

Miscounting loop iterations in nested loops or off-by-one boundary conditions, for example reporting n² iterations when the inner loop starts at the outer index.

Candidates count lines of code rather than executions, and they do not build a table of variable values for small n.

What to do instead

For every loop question, build a trace table for n = 3 and n = 4, record the iteration count, and derive the closed form from the pattern. Check whether the inner bound depends on the outer variable, which changes the total from n² to n(n+1)/2.

Mistake 4

Mixing up pre-increment and post-increment, or assuming left-to-right evaluation of function arguments, in code-tracing questions.

Candidates read expressions as mathematical notation rather than as sequenced side effects, and evaluation order of arguments is often unspecified in the language being tested.

What to do instead

Isolate each ambiguous construct into a two-line program and run it. Learn the rule for the specific language: in C and C++, modifying a variable and reading it in the same expression without a sequence point is undefined behavior, so the correct exam answer may be that the result is unspecified rather than a number.

Mistake 5

Describing a sort or search by name only, unable to state its worst-case complexity, stability, or the precondition a binary search requires.

Candidates memorize 'quicksort is fast' without connecting algorithm properties to the data conditions that produce them.

What to do instead

Build a one-page comparison table for bubble, insertion, selection, merge, quick, and heap sort with best, average, and worst cases, stability, and in-place status. For binary search, write out the sorted-input precondition and trace a search on a 15-element array counting comparisons.

Mistake 6

Mistaking the role of the operating system scheduler, virtual memory, and the cache, for example saying the OS swaps pages to increase cache size or that a context switch copies the entire process image.

Layered abstractions blur together, and candidates learn definitions without the cost model that explains why each mechanism exists.

What to do instead

Draw a hierarchy from registers to cache to RAM to disk with rough latency numbers, then place each mechanism on the diagram: cache reduces average memory latency, virtual memory provides isolation and oversubscription, and a context switch saves and restores register state and switches address space.

Mistake 7

Applying the OSI or TCP/IP layering to the wrong device or protocol, such as placing a switch at layer 3 or ARP above IP.

Candidates memorize layer names but not the encapsulation relationships, so they cannot reason about which header a device inspects.

What to do instead

For each device (hub, switch, router, firewall) and protocol (Ethernet, IP, TCP, UDP, ARP, DNS, HTTP), write the layer and the PDU it handles. Then trace one HTTP request end to end and label the encapsulation at each hop, noting that ARP resolves an IP to a MAC within the local link.

Mistake 8

Computing subnet host counts or usable ranges by formula without subtracting the network and broadcast addresses, or misreading a CIDR prefix.

Candidates apply 2^h mechanically and forget that the all-zeros and all-ones host values are reserved in traditional IPv4 subnets.

What to do instead

For a given prefix, write the block size, the number of addresses, the usable hosts, and the first and last usable address. Practice with /24, /25, /26, /27, and /30 and verify that /30 gives exactly two usable hosts, a common exam check.

Mistake 9

Answering social and legal impact questions with general opinion rather than identifying the specific concept, such as confusing a copyright violation with plagiarism or a phishing attack with social engineering as a category.

These questions look like opinion prompts, so candidates skip precise terminology and lose points on definitional distinctions.

What to do instead

Make a vocabulary list of paired concepts and write one distinguishing sentence for each: copyright versus plagiarism, phishing versus pharming, encryption versus hashing, authentication versus authorization, and open source versus freeware. Anchor each to a concrete scenario.

Mistake 10

Writing pseudocode or a code fragment that ignores the stated input constraints, such as assuming nonempty input or using a sentinel loop that fails on the first element.

Candidates focus on the happy path and do not test their written answer against boundary cases before moving on.

What to do instead

Before finalizing any constructed response, run three cases mentally: empty or zero input, a single element, and a duplicate or maximum value. Adjust the loop bounds and initializations so each case is handled, and state the assumption explicitly if the problem permits it.