Plain-English explanations of the concepts that actually get tested — written against standard course topics and current published exam objectives, then linked straight into free practice on that exact topic.
One page per class, guides in course order: Java · Python · Discrete Math · Networking · Security+ · Calculus
Reproduce a known parity result, explore the example, and learn why a large formula does not prove a problem is hard.
Four question shapes, one table, and a two-week plan. Rereading the chapter is not one of them.
The words a first exam opens with, and the one Python behaviour that makes them real: a typo stops everything before line 1, a bad name waits for its line.
input() always hands you a string. That one fact explains most of the errors in a first program.
Oval, parallelogram, rectangle, diamond: what each shape means, the arrow that goes back up and makes a loop, pseudocode, and turning a chart into Python.
Three kinds of wrong, seven errors worth knowing by name, and the reading order that makes sense of them.
A robot with a pen: moving and turning, the 360 / n rule that draws any shape, colours and fills, functions, and two turtles as two objects.
The stop value is excluded, the accumulator has to accumulate, and a nested loop can be traced reliably — if you write down the right two columns.
import and the dot, math and random, seeds that make dice repeatable, your own module with __name__, and the file name that breaks import.
A function that prints looks right and fails every test. A local variable vanishes the moment the call ends. Both cost marks, and neither looks like a mistake on screen.
number == 5 or 6 or 7 compiles, runs, raises nothing — and is true for every possible value. Plus truthiness, elif chains and why floats break ==.
s.upper() ran, produced the right answer, and threw it away. Plus negative indexes, slicing, traversal, .format() and f-strings.
y = x does not copy a list — it gives the same list a second name. The idea intro Python tests hardest, because you can get it wrong without anything crashing.
Opening a file for writing empties it before you write a byte. Plus key-value lookup, KeyError, .get(), the counting idiom and try/except/else/finally.
Find the biggest, keep and change, count, sort, pair up and work through records: comprehensions, get, sorted vs sort, zip and lists of dictionaries.
Retrieve instead of reread, space the sessions, read every explanation, and trace code by hand — with a two-week plan. Works without a class.
Every beginner Java term, from identifier and literal to instance, parameter and static, pointed at in one parking-garage ticket program that grows section by section.
The six steps from a problem to a working program, walked through one laundromat pricing program: statement, decomposition, class and method design, coding, then testing and revising.
What every word of Hello World is doing — and the exact error each one gives when you change it.
javac makes bytecode, java runs it. Two tools, two kinds of error, and the five you hit first.
Take int bikesAvailable = 12; apart word by word at a bike rental shop: legal names, keywords, literals, final constants and the real compiler errors behind each rule.
All eight types, plus integer division, silent overflow, floating-point drift and char arithmetic.
The plus sign is two different operators. That is where the wrong output comes from.
A campsite booking desk asks for nights, people and a name: nextInt versus nextLine, the empty-line trap and its fixes, and one Scanner per program.
Prefix versus postfix in plain English — why x = x++ does nothing, and the hidden cast inside every compound assignment.
A draft that looks finished, fails to compile, then compiles and is still wrong.
Four methods can share one name, and the compiler picks without ever looking at what they return. Plus what static really means, and the two words everyone swaps.
Where a Java variable can be used and how long it lives, shown with a growing vending machine class: block scope, stack frames, the heap and references.
@param, @return and the comment that becomes a web pageRename and document a coffee-shop LoyaltyCard class step by step: camelCase, PascalCase and constants, /** */ versus /* */, @param, @return, and a real javadoc run.
Test cases that sit on the edge of the rule, the assert that does nothing until you ask, and the classes that box an int.
Integer division, promotion, casts that chop instead of round, the Math class, and the three-step recipe for rounding to two places.
AND, OR and NOT, the right-hand side Java never looks at, the dangling else, and the switch that keeps going without break.
Three ways to say “again”, counting a nested loop's passes on paper, what break and continue skip, and the semicolon that empties a loop.
Indexes from zero, the substring end that is never included, the comparison that checks the wrong thing, and the one String type you can change.
The recipe card you copy and change: extends, the super(...) call every child constructor makes, and overriding versus overloading.
Why your object prints as Pet@1b6d3586, why two identical points are not equal, and the parameter type that breaks a hand-written equals.
One call, the right method: what the variable lets you call, what the object decides to run, casting safely, and the is-a versus has-a test.
The half-finished parent class and the promise any class can make: abstract methods, implements, Comparable, and when to choose which.
The egg carton with numbered cups: new, length, why passing an array lets a method change it, and adding, finding and removing in an oversized array.
Row first, then column: the two different lengths, row-major and column-major loops, row and column totals, ragged rows and three dimensions.
The array that grows: add, get, set, remove, the remove call that deletes the wrong item, size versus capacity, and Vector.
The box with a blank label: generic methods, <T extends Comparable<T>>, generic classes like Pair<A, B>, and what generics cannot do.
The smoke alarm, not the cook watching every pan: reading a stack trace, catch order, finally, the block-count rules, and checked versus unchecked.
Open, use, close: PrintWriter, Scanner versus BufferedReader, the file that stayed empty, and the Scanner that read the file name.
Nesting dolls and the base case: the four questions, watching the stack unwind, and factorial, GCD, Fibonacci, binary search and the Towers of Hanoi.
Why you cannot multiply through by the denominator, how to build a sign chart, and bracket or parenthesis.
Every connective, the one row where a conditional is false, and what a tautology actually is — the definitions a first test opens with.
Only one of the three says the same thing as the original — plus the “only if” vocabulary that causes the swap.
Push the negation inward, flip every quantifier it passes, and don’t let the conditional survive.
The skeleton a grader wants to see, two worked examples, and the line where the hypothesis must appear.
What each one assumes, what each must produce, and how to spot a proof wearing the wrong label.
The division algorithm hands you an exhaustive case split — and even/odd is often too coarse.
Name the witness, then verify it. The half that gets skipped is the half worth marks.
Truth table or chain of named laws — the same result two ways, and when each one is what was asked.
Every connective as a 0/1 formula, the p² = p rule, and how to prove an equivalence by multiplying out.
Line up every player so each beat the next. Induction on the number of players, with the insertion step case by case.
Read a ≡ b (mod n), add and multiply congruences safely, find 3100 mod 7, and meet the composites that fool Fermat.
Write any number as non-consecutive Fibonacci numbers, and the strong induction proof that the greedy method always works.
One-to-one, onto, both: the exact first line of each proof, five worked examples, and why counting is a bijection.
Why x ↦ 3x mod 7 shuffles 1 to 6, how to trace an orbit, and why 3 is a primitive root of 7 but 2 is not.
Fill positions and multiply: the two formulas, the induction behind each, and the traps between them.
Study by domain weight, not chapter order. What the 90 minutes contain, and why 750 is not 83 percent.
Confidentiality, integrity and availability, the controls that serve each, and why strengthening one often weakens another.
One shared key or a public/private pair, when each is used, and why TLS quietly uses both.
Why a hash cannot be reversed, what a salt actually stops, and why a fast hash is the wrong tool for passwords.
Phishing, vishing, smishing, whaling and pretexting, separated by channel, target and technique.
Virus, worm, trojan, ransomware, rootkit and the rest, sorted by the two questions that separate them.
Port-based network access control: a device proves who it is before the network lets it in.
Preparation through lessons learned, why containment comes before eradication, and why sources disagree on the count.
What a SIEM adds to a pile of logs, false positives versus false negatives, and why clock sync is a security control.
The three formulas worked with real numbers, the four risk responses, and why a control can cost more than it saves.
The NCLEX-RN practice app and exam guide are live. Every question in the app carries a written rationale in the meantime.
What gets tested in chapters 1 to 3, every formula on one sheet, the traps, and a seven-day plan.
The edge, the core, store-and-forward, and why FDM and TDM reserve capacity nobody may use.
d_trans = L/R versus d_prop = d/s, traffic intensity, and why the slowest link sets your speed.
Five layers, four packet names, and the nested envelopes that carry your data.
Client-server, sockets, and why an IP address alone cannot deliver a message.
Request line, status line, headers, blank line, body — and what every field is doing.
Why one costs 2 RTT per object and the other costs one for the whole page.
The four components, and why the purchase history is not in the cookie.
Three legs, three protocols, and the one leg SMTP never carries.
Root, TLD, authoritative, local — and writing A, NS, CNAME and MX without reversing them.
Getting a capture that actually contains HTTP, and reading every header field in it.
Ports, sockets, the 8-byte UDP header, and the checksum worked bit by bit with wraparound.
Checksums, ACKs, sequence numbers and timers, each added to fix one problem, plus the stop-and-wait math.
Sequence numbers count bytes, ACKs name the next byte wanted, and three duplicate ACKs trigger a resend.
The rwnd formula worked out, SYN / SYNACK / ACK with real numbers, and the FIN_WAIT and TIME_WAIT states.
One router moving one packet, versus the whole network choosing paths, and what the data and control planes are.
The four parts of a router, the three kinds of switching fabric, head-of-line blocking, output queues, buffer sizing and scheduling.
Each IPv4 header field in plain words, a worked checksum, and fragmentation offsets, flags and lengths computed step by step.
What a.b.c.d/x means, how to find the subnets in a network, and how to count and carve address blocks.
The four DHCP messages, where address blocks come from, and how NAT shares one public address by rewriting ports.
How a router picks one forwarding entry out of several matches, and how aggregation shrinks routing tables.
The fixed 40-byte IPv6 header, what was dropped from IPv4, how to shorten an address with ::, and how a tunnel carries IPv6 across IPv4-only routers.
How every router gets the whole map, and Dijkstra’s algorithm worked row by row on a six-router network.
The Bellman-Ford equation worked on three routers, why bad news travels slowly, and how poisoned reverse helps.
Why the Internet is split into autonomous systems, and how OSPF floods link states and runs Dijkstra inside each one.
How networks advertise prefixes to each other with AS-PATH and NEXT-HOP, and how BGP chooses among routes using policy first.
ICMP types and codes, how ping works, and how traceroute uses TTL-expired and port-unreachable messages to list every router on a path.
No guides match that yet.
These are not written yet. They are listed so you can see where each subject is going — not as links.
Java · What a NullPointerException is telling you
Calculus · Involutions · Exponential equations · Solving trig equations · Trig identities · Conic tangents
Discrete Math · Rules of inference and common fallacies · Strong induction and when to use it · The well-ordering principle · Sets and set identities · Functions, injections and surjections · Counting and the pigeonhole principle
Networking · Error detection and multiple access · Ethernet, switches and ARP · Network security basics
Security+ · IDS vs IPS · SPF, DKIM & DMARC · Access control models (RBAC, ABAC, DAC, MAC) · Public key infrastructure and certificates · Network segmentation and zero trust
Topic-selectable practice — offline, no ads, no account.
Choose your subject →