Skip to content
DenseChip
Learn
PracticeCode labInterview

DenseChip

Navigate

Menu

LearnPracticeCode labInterview

Tools

All toolsSV editorCode repoResume
DenseChip

Practice, courses, and chip-design tools in one focused workspace.

LearnPracticeCode labInterviewToolsLearning paths

© 2026 DenseChip

AboutContactPrivacyTerms
Skip to lesson

Course contents

  • How to Use This Course
  • Reading Paths
  • Concept Map
  • Meet DCRouter
  • Glossary
  • Part 0: What Verification Is8
  • Part 1: What Can Go Wrong11
    • A Taxonomy of Bugs
    • Specification Bugs
    • Corner Cases and Boundaries
    • Concurrency and Races
    • Integration and Interface Bugs
    • Configuration and Mode Bugs
    • Performance Bugs
    • Reset, Clock and Power Bugs
    • Where Bugs Hide
    • Classifying the Bug Zoo
    • Drills: What Can Go Wrong
  • Part 2: Specifications as Checkable Rules8
  • Part 3: Observability and Controllability7
  • Part 4: Stimulus11
  • Part 5: Checking11
  • Part 6: Coverage10
  • Part 7: Formal and Simulation10
  • Part 8: Verification Levels and Reuse8
  • Part 9: Planning and Risk9
  • Part 10: Emulation and Prototyping8
  • Part 11: Post-Silicon Validation8
  • Part 12: Bug Economics8
  • Part 13: Debug7
  • Part 14: Sign-Off7
  • Part 15: Verification in Context8
  • Part 16: Case Studies5
  • Part 17: Capstones5
  • Part 18: Interview Preparation6
Loading lesson

‹First Principles of Verification Strategy
  1. Topics
  2. First Principles of Verification Strategy
  3. Part 1: What Can Go Wrong

Part 1 · What Can Go Wrong · All levels

Part 1: What Can Go Wrong

What can go wrong? Classify a bug by kind and predict where it hides.

  • 11topics
  • 11lessons
On this page

    Part 1 answers: What can go wrong?

    Where Part 1 sits among the sixteen questions of the course.

    You cannot look for bugs you cannot imagine. Bugs fall into recognisable classes: corner cases at boundaries, races between events in the same cycle, blocks that pass alone and fail together, configurations nobody tried, designs that are correct but too slow, and specifications that were wrong to begin with.

    Each class hides in a different place and is found by a different technique. This part builds the taxonomy the rest of the course uses, then sorts DCRouter's 24 planted bugs into it, with a prediction you will test in every later part: which technique will catch which bug.

    After this part you can

    • Classify a bug by kind and predict where it hides.

    • Explain why integration, configuration and performance bugs escape block-level tests.

    • Predict which verification technique is most likely to find a given class of bug.

    Warm-up: three questions from Part 0

    Answer each in your head before opening it. If two or more feel shaky, revisit Part 0: What Verification Is first.

    Check yourself Why can simulation never prove a design correct?

    The number of input sequences grows exponentially with state and time; any practical simulation tries a vanishing fraction of them.

    Check yourself What is the difference between verification and validation?

    Verification asks whether the design matches its specification; validation asks whether the specification (and product) meets the real need.

    Check yourself Why does a bug found in silicon cost so much more than one found in RTL?

    Fixing it needs new masks, months of schedule and possibly field recalls, against an edit and a rerun at RTL.

    Lessons

    #

    Lesson

    Level

    Status

    1.1

    A Taxonomy of Bugs

    W · Working

    Ready

    1.2

    Specification Bugs

    W · Working

    Ready

    1.3

    Corner Cases and Boundaries

    W · Working

    Ready

    1.4

    Concurrency and Races

    S · Senior

    Ready

    1.5

    Integration and Interface Bugs

    S · Senior

    Ready

    1.6

    Configuration and Mode Bugs

    S · Senior

    Ready

    1.7

    Performance Bugs

    S · Senior

    Ready

    1.8

    Reset, Clock and Power Bugs

    S · Senior

    Ready

    1.9

    Where Bugs Hide

    W · Working

    Ready

    1.10

    Classifying the Bug Zoo

    W · Working

    Ready

    —

    Drills and checkpoint

    all levels

    Ready

    Every lesson in this part is ready. Work through them in order: each one sets up the problem the next one solves.

    Tip

    DCRouter in this part. Step 2: sort the 24 Bug Zoo entries by class and predict which technique will catch each. DCRouter is the small router you verify across the course, with 24 planted bugs; see Meet DCRouter.

    Where other courses go deeper

    This course teaches the decisions behind verification. These lessons teach the tools and syntax that carry them out, so this part links to them instead of repeating them.

    • DV interview puzzles: Scenario Debug Puzzles

    • CDC and RDC course

    Related topics

    • Course hub

    • Previous: Part 0 · What Verification Is

    • Next: Part 2 · Specifications as Checkable Rules

    PreviousNext: A Taxonomy of Bugs

    Up next

    Up nextA Taxonomy of Bugs

    Sign in to save progress

    Practice this lessonReport an error

    See also

    • How to Use This Course
    • Reading Paths
    • Concept Map