Multi-Base Number Slider Workout (FND-101 Weeks 1-2)

This is a Tier-1-graded worksheet. Submit this filled worksheet only. The Week 1 paper-conversion lab (1.1 Binary by Hand) is the deeper artifact; today is the calibration that confirms your hand work and surfaces the patterns hand work alone hides.

Purpose

Week 1 lab 1.1 had you convert 20 numbers between decimal and binary on paper. That work built the column-weight algorithm in your fingers. Today's worksheet drives the Multi-Base Number Slider (/workbench/static/multi-base-slider.html) to confirm your hand answers and surface two patterns paper alone obscures: (a) the bit-grid lights up the on-bits at the same instant the decimal / hex / binary / octal / ASCII columns update, so the relationship between bit positions and digit weights is visible at a glance, and (b) the ASCII column tells you which decimal values land on a printable character versus a control code, which is the missing piece between Week 1 (numbers) and Week 2 (characters).

The slider's five columns (Decimal / Hexadecimal / Binary / Octal / ASCII) show the same value in five lenses simultaneously. The bit grid below shows which bit positions contribute to that value. The 8-bit / 16-bit toggle lets you see what happens when a number outgrows a byte. You use those affordances to answer two kinds of question this worksheet poses: predictive (what will the hex column read when I set decimal to 200?) and observational (the binary column reads 1011 0001; what byte is that in hex, and is it printable?).

The pedagogical claim of FND-101 Week 1 is that every base is a different lens on the same quantity. The slider makes that claim visual: drag once, see all five lenses update together. The pedagogical claim of Week 2 is that text is a numbers convention. The slider makes that visual too: drag through 0-127 and watch the ASCII column either name a control code or print a glyph.

The deeper purpose: this worksheet builds the intuition that you carry into Week 2's xxd hex dump (xxd shows you bytes; the slider tells you what each byte means) and into every later chapter that interprets bytes (CSA-101 Ch 4 instruction encoding; RE-011 Week 3 ELF headers; NET-101 Week 9 HTTP wire format).

Learning Objectives

By the end of this worksheet, you will be able to:

1. Predict the hex representation of any decimal value 0-255, and verify the prediction in the slider's hex column (Apply; Week 1 §1 positional notation).
2. Predict the binary representation of any hex value 0x00-0xFF, and verify the prediction in the slider's binary column (Apply; Week 1 §3 conversion methods).
3. Identify which decimal values map to printable ASCII characters and which map to control codes, by reading the slider's ASCII column (Apply; Week 2 §2 ASCII).
4. Recognize the edge cases of an 8-bit byte (0, 255, 256 wrap, 0xff vs 0x100), by toggling the 8-bit / 16-bit width control (Analyze; Week 1 §2 byte boundary).
5. Articulate one pattern the slider surfaces that hand-conversion does not, in 3-5 sentences (Evaluate; Week 1 §1 vs §3 vs Week 2 §2 integration).

Equipment Checklist

• Modern web browser (Chromium-family preferred)
• Slider URL open: https://virtuscyberacademy.org/workbench/static/multi-base-slider.html
• FND-101 Week 1 prose re-read through Section 3
• FND-101 Week 2 prose Section 2 re-read
• Paper notebook for predictions (do NOT slide before you predict)
• An ASCII chart at hand (the slider's ASCII column is authoritative, but having a printed chart speeds the predictions)
• Lab 1.1 (Binary by Hand) submitted PASS

Step-by-Step Procedure

This worksheet takes ~60 minutes. Plan one sitting.

Stage 1 - Load the slider and read the layout

• Step 1. Open the slider at the URL above. Confirm you see: a slider control + decimal input on top; an 8-bit / 16-bit toggle; a 5-row table showing the value in Decimal / Hexadecimal / Binary / Octal / ASCII; and a clickable bit grid below the table.
• Step 2. Confirm the page loaded with decimal 65 selected (the default). The hex column should read 0x41, the binary column 0100 0001, and the ASCII column 'A'. If any column reads otherwise, refresh the page.
• Step 3. Read the pedagogy paragraph below the bit grid. The headline claim ("the byte does not care; the convention does") is the answer to Reflection 4 below; keep it in mind as you work the tables.

Stage 2 - Decimal to hex (5 predictions; Table A)

For each row of Table A: first fill the "Predicted hex" column from memory or by hand on paper (Week 1 §3 method). Then drag the slider (or type the decimal value into the decimal input) and fill the "Observed hex" column from what the slider's Hexadecimal row reads. If the two disagree, mark "miss" in the Match column and look back at your prediction.

The numbers chosen exercise the byte boundary, the printable-ASCII range, and a known unprintable.

• Step 4. Fill all 5 prediction rows BEFORE any slider interaction. Photograph or scan the paper predictions if your grader requires evidence the prediction came first.
• Step 5. Set the slider (or decimal input) to each value in turn. Fill the "Observed hex" column.
• Step 6. Mark "match" or "miss" per row. For any miss, walk through the hand-conversion algorithm one more time and identify which step you got wrong.

Stage 3 - Hex to binary (5 predictions; Table B)

For each row of Table B: first fill the "Predicted binary" column from hand by mapping each hex digit to its 4-bit pattern (Week 1 §3 nibble method: each hex digit is exactly 4 bits). Then read the slider's binary column at that hex value.

Recall: hex 0 = 0000, 1 = 0001, 2 = 0010, ..., 9 = 1001, A = 1010, B = 1011, ..., F = 1111.

The slider only accepts decimal input; convert each hex value to decimal first OR click the bit grid to set the pattern. Either approach is fine; the prediction column is what is graded.

• Step 7. Fill all 5 prediction rows BEFORE any slider interaction.
• Step 8. Set the slider to each value (via decimal conversion or bit-grid clicking) and read the binary column. Fill the "Observed binary" column. Note: the slider formats binary as 4-bit groups (e.g., 1010 1111); reproduce the grouping in your prediction so the rows compare cleanly.

Stage 4 - Hex to ASCII (5 predictions; Table C)

For each row of Table C: first fill the "Predicted ASCII" column from your Week 2 §2 ASCII memory. The slider supplies the authoritative ASCII column; this exercise builds your recall of the printable range.

For each hex value, predict: (a) is the value in the printable range (0x20-0x7E)? (b) if printable, which glyph? (c) if not printable, what control-code mnemonic does the slider show (NUL, SOH, ..., US, DEL)? The slider's ASCII column either prints 'X' for printable characters or names the control code in parentheses for the rest.

• Step 9. Fill all 5 prediction rows BEFORE any slider interaction.
• Step 10. Drive the slider to each value and confirm. Fill the "Observed ASCII" column.

Stage 5 - Edge cases (Table D)

The 8-bit / 16-bit toggle changes the slider's maximum value: 255 in 8-bit mode, 65535 in 16-bit mode. The edge cases 0, 255, 256, 0xff, and 0x100 test the byte boundary - the moment the value outgrows an 8-bit byte and needs a second.

• Step 11. Set the toggle to 8-bit. Slide to 0. Read the hex, binary, ASCII columns. Fill row 1 of Table D.
• Step 12. Slide to 255 (the maximum in 8-bit mode). Read the columns. Fill row 2.
• Step 13. Try to type 256 into the decimal input while still in 8-bit mode. Observe: what happens? (The slider clamps the input.) Fill row 3.
• Step 14. Switch the toggle to 16-bit. Now set decimal to 256. Read the columns - the binary should now show 9 bits' worth of pattern (i.e., a 1 at bit position 8 and zeros elsewhere). Fill row 4.
• Step 15. Set decimal to 0xff (= 255). Then add 1 (= 256, = 0x100). Watch the hex column transition from 0xFF to 0x0100. This is the "byte wrapped" moment from Week 1 §4 (overflow); the slider, being in 16-bit mode, does not wrap but extends. Fill row 5.

Stage 6 - Reflection

Answer the 4 reflection prompts below in 2-4 sentences each.

Data Entry Tables

Table A - Decimal to Hex (Steps 4-6; PREDICT before sliding)

Table B - Hex to Binary (Steps 7-8; PREDICT before sliding)

Table C - Hex to ASCII (Steps 9-10; PREDICT before sliding)

The bit-5 (0x20) case-swap exercise from Week 2 §2: predict what 0x61 displays. After you finish row 4 above, try 0x61 and confirm the lowercase pattern. Note in margin.

Table D - Edge Cases (Steps 11-15)

Reflection Prompts

Answer in 2-4 sentences each.

1. The slider shows the same number in five bases at once. Which of the five columns did you find yourself looking at most often during Tables A through C? Why? (There is no wrong answer; the question calibrates which lens has become your default.)

2. The bit grid lights up the on-bits at the same instant the decimal / hex / binary / octal columns update. What pattern in the bit grid did you notice that you do not think you would have seen if you only saw the binary column as a row of digits? (Hint: the column-weight labels above each bit position make the powers-of-two ladder visible; in a flat binary string they are implicit.)

3. Table D row 5 showed the byte boundary directly. In 8-bit mode the value 256 is unrepresentable; in 16-bit mode the same value lights bit position 8 (a bit no 8-bit byte has). Explain in your own words why CSA-101 Ch 4's RV32I-Lite instructions are 32 bits and not 8: what would not fit if instructions were one byte each? (You do not need to know RV32I-Lite yet; reasoning from "256 distinct values" is enough.)

4. The brief's headline question. What did you see using the slider that you could not see when computing by hand? (Hint: a hand conversion shows you the answer in one base; the slider shows you the answer in five bases at the same instant. A good answer names a specific relationship between two columns - bit position vs hex digit, decimal value vs ASCII glyph, on-bits in the grid vs the count of 1s in the binary string - that became visible only because both lenses were on screen together.)

Toolchain Diary Trigger

This worksheet introduces one new tool:

• (required) Add a ## Multi-Base Number Slider entry to your Toolchain Diary. The entry should reference: (a) the URL where the tool lives (https://virtuscyberacademy.org/workbench/static/multi-base-slider.html), (b) the 5-base contract (Decimal / Hexadecimal / Binary / Octal / ASCII), (c) one observation about the bit grid that surprised you (often: how few bits are on for "normal" numbers like 100 vs how many are on for 255 - the visual asymmetry is the entire content of "bit count" as a concept).
• (recommended) Append a ## Re-encountered in fnd-101-lab-multi-base-slider section to your existing Lab 1.1 (Binary by Hand) entry. The new section should reference how the slider verified your paper conversions and what pattern (if any) the verification surfaced.

Submission Checklist

• This worksheet, with Tables A, B, C, D filled
• All 4 Reflection Prompts answered
• Prediction columns in Tables A, B, C filled BEFORE the corresponding observation columns (or honest acknowledgement of the order if you did not)
• Table D row 5's bit-position observation filled (the position that lights up at 256)
• Toolchain Diary entry for the Multi-Base Slider added

Pass/Fail Self-Evidence (Tier 1 of the rubric)

Every gate must be checked.

• Gate 1. Tables A, B, C predictions filled before observations (the discipline that makes this lab worth doing).
• Gate 2. Every "Match" column entry is honest. Misses are kept; do not edit predictions after the fact.
• Gate 3. Table D rows 1, 2, 4 hex / binary / ASCII values match the slider's display.
• Gate 4. Reflection 4 (the brief's headline) names a specific cross-base relationship the slider made visible.

If any gate is unchecked, do not submit yet.

Common Pitfalls

The five most common first-attempt failures:

1. Slid before predicting. The prediction columns lose their calibration value once you have seen the answer. If you slid first and back-filled predictions, redo honestly with a different set of numbers from FND-101 lab 1.1's appendix.
2. Used the slider's clamp to "fix" an 8-bit overflow. Table D row 3 is supposed to show you what the slider does with out-of-range input (it clamps to 255). The pedagogical point is that the byte cannot hold 256; observe the clamp rather than fight it.
3. Forgot to switch to 16-bit mode for Table D rows 4 and 5. The toggle is two buttons at the top; click the 16-bit button (the aria-pressed state changes). The decimal input's max also changes from 255 to 65535.
4. Misread the slider's binary column for hex values. The binary column groups bits as XXXX XXXX (or XXXX XXXX XXXX XXXX in 16-bit mode). Each 4-bit group is one hex digit. If your prediction has different grouping (or no spaces), normalize the grouping before checking the match.
5. Confused 0x100 with 0x10. Hexadecimal positional notation: 0x10 = 16 (decimal); 0x100 = 256 (decimal). The trailing zeros multiply by 16, not by 10. The slider's hex column is your authority here.

Forward Pointer

Lab 1.2 (Hex Dump) is the next FND-101 worksheet. After today's slider workout, you will run xxd against a small text file and recognize the bytes - the slider's ASCII column told you which byte is which character; lab 1.2 confirms that bytes really do appear in files exactly as the slider says.

Lab 2.1 (UTF-8 Encoding) extends the same idea from one-byte ASCII to multi-byte UTF-8. The Week 2 §4 algorithm splits a code point across 2, 3, or 4 bytes; today's slider only handles single bytes (the printable-ASCII case is the 1-byte UTF-8 case). Lab 2.1's xxd hex dumps of accented characters and emoji will show you the multi-byte bytes the slider cannot.

Beyond FND-101: every later chapter that interprets bytes leans on today's intuition. CSA-101 Ch 4 has you hand-encode RV32I-Lite instructions as 32-bit words (use the encoding card; the slider's mental model carries over even though the slider tops out at 16 bits). RE-011 Week 3 has you read ELF headers as a byte strip (the same "what does this byte mean" question, with the field labels coming from the spec instead of the slider). NET-101 Week 9 has you read HTTP request lines in a pcap (text in ASCII; the slider taught you which byte is which character). The slider is the calibration; every later byte-reading exercise inherits the calibration.

LAB WORKSHEET COMPLETE - Multi-Base Slider Workout v1.0; Tier-1-graded worksheet-completion; YAML frontmatter (12 fields incl grading_disposition: Tier-1 worksheet-completion. Every prediction row in Tables A-C filled BEFORE the corresponding observation row; edge-case Table D filled accurately against the slider; all 4 reflection prompts answered) + 5 Bloom-ordered LOs tied to FND-101 Week 1 §1 positional notation + Week 1 §3 conversion methods + Week 2 §2 ASCII bit-5-case-swap + Week 1 §2 byte boundary + Week 1-Week 2 integration + 7-item Equipment Checklist (incl slider URL + Week 1 + 2 prose re-read + paper-notebook-for-prediction discipline + Lab 1.1 PASS gate) + 6-stage / 15-step Procedure (load slider + read pedagogy paragraph -> Table A decimal-to-hex with 5 predictions BEFORE sliding -> Table B hex-to-binary with 5 predictions BEFORE sliding -> Table C hex-to-ASCII with 5 predictions BEFORE sliding -> Table D edge cases 0/255/256/0xff/0x100 with byte-boundary observation -> reflection) + 4 Data Tables (A: decimal-to-hex prediction-then-verify / B: hex-to-binary prediction-then-verify / C: hex-to-ASCII prediction-then-verify incl bit-5-case-swap aside / D: 5 edge-case rows with slider-clamp + bit-position-at-256 observations) + 4 Reflection Prompts (which-of-5-columns-is-default-lens + bit-grid-pattern-not-visible-as-flat-binary-string + why-RV32I-Lite-instructions-are-32-not-8-bits + the-brief's-headline what-did-you-see-with-slider-not-with-paper) + Toolchain Diary Trigger (one new tool: Multi-Base Number Slider with URL + 5-base contract + observational surprise; recommended re-encounter section on Lab 1.1 paper conversion verified by slider) + Submission Checklist (5 items) + Pass/Fail Self-Evidence (4 Tier-1 gates) + Common Pitfalls (5 numbered) + Forward Pointer to Lab 1.2 (Hex Dump uses slider's calibration) + Lab 2.1 (UTF-8 multi-byte extends single-byte case) + CSA-101 Ch 4 32-bit-instruction-encoding inherits + RE-011 Week 3 ELF byte-strip inherits + NET-101 Week 9 HTTP-text-in-ASCII inherits + closing thesis on slider-as-calibration-for-every-later-byte-reading; references multi-base slider spec from R-INTERACTIVE-FND-101-MULTI-BASE-SLIDER-2026-05-13 (commit 394efc8) + the bit-5-case-swap from Week 2 §2 implicitly via Table C aside; no new pedagogical anchors added per voice-contract.