2025 FE (A & B) — Comprehensive Study Notes Summary & Study Notes

📘 Source summary

This section is based on the question set from 2025A_FE-A_Questions.pdf. It covers a broad range of fundamentals frequently tested on the FE exam: computer architecture, algorithms, data structures, operating systems, networking, security, databases, software engineering, project management, and information systems concepts.

🧮 Key formulas & short reminders

• IEEE-754 (single precision) representation: a 32-bit float uses fields Sign (S, 1 bit), Exponent (E, 8 bits), Fraction (F, 23 bits). Value (for 0 < E < 255) is $(-1)^S \times 2^{E-127} \times (1+F)$, where $F = b_1 \times 2^{-1} + b_2 \times 2^{-2} + ... + b_{23} \times 2^{-23}$.
• HDD average access time = average seek time + controller overhead + average rotational latency + transfer time. Rotational latency (average) = half a revolution. Transfer time = data size / transfer rate.

⚙️ Algorithms & Data Structures (high-yield)

• Bit shifts for multiplication: shifting left by 1 multiplies by 2; combine shifts plus adds/subtracts to form other multipliers (e.g., $9n = 8n + n$ ⇒ shift 3 left + add).
• Two’s complement integers: be careful with sign when shifting or arithmetic.
• Linked lists (doubly & singly): pointer updates on insertion/deletion must adjust only the affected neighbor pointers; track prev/next carefully.
• LRU page replacement: evict the page least recently used — simulate reference order to determine which page is replaced.
• Stack/Queue operations: track tos or head/tail indices precisely; off-by-one errors are common when index origin ≠ 0.

🖥 Computer systems & OS

• Interrupt handling / preemption: account for interrupt priority and processing times when calculating CPU availability; nested interrupts affect main-process CPU time.
• Scheduling metrics: FCFS turnaround times require cumulative completion times; compute each process finish time then average.
• Disk I/O calculations: convert units consistently (1 MB = 1024 kB if exam uses that), include all components (seek + overhead + rotation + transfer).

🌐 Networking & Security

• ARP requests use the broadcast MAC address for destination: FF:FF:FF:FF:FF:FF. ARP responses use the target’s actual MAC.
• Digital signatures: verify a signature created with Y’s private key by using Y’s public key to confirm origin and integrity.
• Common threats: USB-based malware dropped in public is baiting (social-engineering physical vector). DNS cache poisoning causes users of the poisoned DNS server to reach the attacker-controlled server.
• WAF placement: place a Web Application Firewall where it can inspect HTTP(S) requests before they reach the web server but after SSL termination if the WAF cannot decrypt; consider SSL accelerators in the flow.

🗄 Databases & Transactions

• Relational attributes: attribute order has no semantic meaning; attributes are named fields in a relation.
• Functional dependencies & transitivity: if A → B and B → C then A → C is a transitive dependency (watch for correct attribute chains).
• SQL subqueries: use IN (SELECT ...) to filter by membership of a set (e.g., find employees in departments located in 'New York').
• ACID: Isolation ensures transactions execute without interfering with each other.

🧰 Software engineering & project management

• Design vs implementation: architecture design transforms requirements into a top-level structure; module-level details and line-by-line code are later phases.
• Testing types: acceptance tests are conducted by users to confirm software meets business needs; state-transition tests check event/state combinations.
• Cost estimation (PERT / three-point): expected = (optimistic + 4×most_likely + pessimistic)/6.
• Defect cost modeling: multiply expected discovered defects by probability and per-defect correction cost; apply discovery-rate and classification percentages.

📌 Exam tips (FE-A style)

• Read units carefully (ms vs s; MB = 1024 kB often used). Use consistent conversions.
• For combinatorics and probability, treat grouped entities (e.g., 3 friends together) as a block when appropriate.
• For logic circuits and boolean algebra, convert gate diagrams to minimal expressions before matching answers.
• Practice interpreting exam-style diagrams (state machines, networks, project arrow diagrams) — many questions are diagram-driven.

✅ How to practice with this source

• Work through the representative problems in the question set: floating-point conversion, disk access time arithmetic, scheduling examples, and SQL subqueries.
• After solving, check your reasoning line-by-line: many FE questions hinge on a single unit conversion or sign error.

📗 Source summary

This section is based on 2025A_FE-B_Questions.pdf (Subject B). It emphasizes programming fundamentals, pseudocode interpretation, algorithm design, data structures, recursion, and basic OO concepts — typical for the coding/problem-solving portion.

🧩 Pseudocode conventions (important)

• Index base: many problems in this source use array index starting at 1. Adjust loops and bounds accordingly.
• Control structures: for, while, and if/elseif/else follow standard flow; watch when endfor or endwhile is implicitly triggered.
• Undefined state: variables set to undefined must be checked before use (common in list/stack problems).

🔁 Common algorithmic patterns

• Summations & filters: to sum elements meeting a condition (e.g., even elements), increment the iterator correctly each loop iteration; avoid accidental infinite loops.
• Mode computation: frequency counting by nested loops works for small N; maintain both current-mode value and its count, and update when a higher count is found.
• Subarray sum (brute force & two-pointer): nested loops scanning start and end indices can be optimized when numbers are nonnegative (sliding window/two-pointer).
• Reverse digits: extract remainder r = temp mod 10, build reversed number rev = rev * 10 + r, and shrink temp by integer division by 10.
• Prime generation (trial division): test divisibility up to integer part of sqrt(number); maintain isPrime flag and a count of primes printed.

🔗 Data structures & recursion

• Recursive linked-list reversal: base-case when head.next is undefined; unwind recursion to reconnect nodes. Carefully set head.next to elm after recursion.
• Stack implementation: maintain tos (top-of-stack) index carefully for push/pop; off-by-one and empty/full conditions are frequent pitfalls.
• Queue-based BFS traversal: enqueue start node, mark visited, then loop: dequeue → output → enqueue unvisited neighbors; respects adjacency matrix representation.

🧭 Object-oriented behavior

• Inheritance & method overriding: a subclass constructor should call the superclass constructor; when passing a subclass instance to a superclass method expecting the superclass type, only superclass-visible members/methods are used (unless overridden).
• Example (Rectangle / Cuboid): enlarging a Rectangle by a Cuboid object may only add length/width (height ignored) if the signature expects Rectangle; watch actual parameter types and available fields.

⚠️ Common pitfalls to practice

• Off-by-one errors (array indices starting at 1 vs 0).
• Not updating loop variables inside while loops causing infinite loops.
• Mixing up when to increment count vs set isPrime in prime-generation loops.
• Using integer division vs floating division for digit-stripping or bounds.

✅ How to practice with this source

• Translate each pseudocode to an actual implementation in your preferred language and run test cases (especially edge cases: small N, identical elements, single-element arrays).
• Trace recursion and stack behavior on paper for short lists to verify pointer updates.
• For BFS, draw the adjacency matrix and simulate the queue to ensure output order matches expected traversal.

📘 Source summary

This section references 2025A_FE-A_Answers.pdf, the official answer set for Subject A. Use the answers file as the definitive key to validate your solutions and to study common reasoning patterns used by the exam authors.

🔎 How to use the answers effectively

• Check your process, not just the final choice. For each problem, compare reasoning steps (unit conversions, intermediate calculations, truth tables, pointer updates) against the answer; identify exactly where your reasoning diverged.
• Annotate weak areas. If multiple incorrect answers arise from the same topic (e.g., disk I/O timing or functional dependencies), mark that topic for deeper review.

📊 Patterns to learn from answer keys

• Many incorrect candidate choices exploit common mistakes: unit mismatch (kB vs MB), wrong sign in two’s complement, mis-ordered precedence in logic expressions, and off-by-one errors in indexing.
• For algorithmic problems, exam answers often assume standard safe conventions (e.g., integer truncation in digit operations, average-case assumptions for scheduling). Keep those conventions in mind while solving.

✍️ Active study steps when you have the answers

1. Re-solve each question you missed using the answer as a guide, writing out the corrected steps.
2. Create short notes (2–3 bullets) per missed question describing the conceptual error and a one-line correction.
3. Group missed questions by topic and schedule targeted practice sessions (e.g., five disk I/O problems, five boolean algebra simplifications).

✅ Exam-readiness checklist using the answers file

• Have you resolved every problem you originally got wrong and can explain the correct answer in one or two sentences?
• Do you recognize the common distractors in multiple-choice items and why they are incorrect?
• Can you re-run the arithmetic (with correct conversions) under timed conditions to build speed and accuracy?

📗 Source summary

This section references 2025A_FE-B_Answers.pdf — the official answer set for Subject B. Use it to verify algorithmic logic, control-flow corrections, and typical coding pitfalls shown in the exam’s pseudocode problems.

🧠 How to study using the Subject B answers

• Trace-and-compare: For each pseudocode question you attempted, write out a small trace (input, intermediate variable values, and output). Compare with the official answer to find where your loop or index updates differed.
• Recursion & pointer checks: Pay special attention to answers for linked-list recursion problems — they often hinge on subtle pointer assignments during recursion unwind.

🔧 Common corrected items seen in answers

• Proper increment/decrement inside while/for loops to avoid infinite loops.
• Correct maintenance of tos for stack push/pop (pre-increment vs post-increment matters when array index base is 1).
• Correct bounds for nested loops (e.g., subarray end index must range to N, not N-1, when inclusive).

📝 Practical study steps

1. Implement all pseudocode solutions in a language you use; unit-test edge cases (empty lists, single element, maximum index).
2. For each incorrect run, consult the answers file and update both code and mental checklist of pitfalls (index base, integer division, loop exit condition).
3. Time yourself solving similar short algorithmic problems to build speed; many Subject B questions reward correct reasoning quickly.

✅ Final prep tips

• Keep a short one-page cheat-sheet listing common loop patterns, recursion base/unwind patterns, and stack/queue index updates for quick review before the exam.
• Use the answer files to build that cheat-sheet: extract repeated patterns and official-correct assignments/operations and memorize them.