MicroSims

Interactive simulations that let you explore computer science concepts by experimenting in real time. Click any card to launch the MicroSim.

Total MicroSims: 114 | Chapters covered: 19

Chapter 1: Intro to Computer Science

• Computational Thinking Pillars

  

  Visualize the four pillars of computational thinking: decomposition, pattern recognition, abstraction, and algorithms.

• Inside a Computer

  

  Explore the internal components of a computer and how they work together.

• Binary Number Explorer

  

  Convert between binary and decimal and see how computers represent numbers.

• ASCII Character Map

  

  Discover how characters are encoded as numbers using the ASCII standard.

• Symbol Character Quiz

  

  Test your knowledge of ASCII symbol characters by identifying them by name.

• Python vs Java Language Trends

  

  Compare the popularity of Python and Java from 2010 to 2025 in an interactive line chart.

• Compiled vs. Interpreted Languages

  

  Compare how compiled and interpreted languages turn source code into running programs.

Chapter 2: Python Fundamentals

• Python REPL vs. Scripts

  

  Compare interactive REPL mode with running saved Python scripts.

• Python Data Types Overview

  

  Explore Python's built-in data types and how they behave.

• Arithmetic Operators Explorer

  

  Try out Python's arithmetic operators and see results update live.

• String Operations Playground

  

  Experiment with slicing, concatenation, and other string operations.

• Expressions vs. Statements

  

  Learn the difference between expressions that produce values and statements that perform actions.

• Code Readability Comparison

  

  See how formatting and naming choices affect how easy code is to read.

Chapter 3: Boolean Logic

• Comparison Operator Explorer

  

  Test comparison operators and see how Python evaluates them to True or False.

• Logical Operator Venn Diagrams

  

  Visualize AND, OR, and NOT using interactive Venn diagrams.

• Interactive Truth Table Builder

  

  Build truth tables for Boolean expressions and check your understanding.

• Truthiness Tester

  

  Find out which Python values are "truthy" and which are "falsy."

• Order of Operations Visualizer

  

  See how Python evaluates Boolean expressions step by step.

• De Morgan's Laws Visualizer

  

  Explore how NOT distributes over AND and OR with De Morgan's Laws.

Chapter 4: Control Flow

• Control Flow Patterns

  

  Explore the three fundamental control flow patterns: sequence, selection, and iteration.

• If-Elif-Else Flowchart

  

  Visualize how Python evaluates chained if-elif-else conditions as a flowchart.

• Range Function Explorer

  

  Experiment with Python's range() function and see the sequence of numbers it generates.

• Break vs Continue Visualizer

  

  See how break and continue alter the flow of a loop with step-by-step animation.

• Nested Loop Grid Visualizer

  

  Watch nested loops fill a grid cell by cell to understand inner and outer loop behavior.

• Loop Patterns Comparison

  

  Compare for loops, while loops, and other iteration patterns side by side.

Chapter 5: Working with Strings

• String Indexing Visualizer

  

  See how Python accesses individual characters in a string using positive and negative indices.

• String Slicing Playground

  

  Type slice expressions and see which characters are selected with visual highlighting.

• Split and Join Visualizer

  

  Watch how split() breaks strings into lists and join() reassembles them.

• String Formatting Comparison

  

  Compare f-strings, format(), and % formatting approaches side by side.

• Palindrome Checker

  

  Type a word or phrase and see step-by-step how Python checks if it's a palindrome.

• String Methods Explorer

  

  Try out common string methods and see how they transform text in real time.

Chapter 6: Functions and Modular Design

• Function Anatomy

  

  Explore the parts of a Python function: def keyword, name, parameters, body, and return value.

• Function Call Flow

  

  Trace how Python executes function calls, passes arguments, and returns values.

• Arguments vs Parameters

  

  Understand the difference between parameters (in definitions) and arguments (in calls).

• Variable Scope Visualizer

  

  See how local and global variable scopes work when functions are called.

• Modular Design Builder

  

  Build a program from small, reusable functions to see the power of modular design.

• Function Pattern Gallery

  

  Browse common function patterns: pure functions, predicates, accumulators, and more.

Chapter 7: Higher-Order Functions and Recursion

• Higher-Order Functions Flow

  

  Visualize how functions can accept other functions as arguments and return them.

• Map-Filter-Reduce Pipeline

  

  Watch data flow through map, filter, and reduce transformations step by step.

• Factorial Recursion Tree

  

  See how recursive calls build a tree of factorial computations that unwind to produce the answer.

• Recursive Call Stack Visualizer

  

  Watch stack frames push and pop as a recursive function executes.

• Fibonacci Tree Visualization

  

  Explore the branching tree of recursive Fibonacci calls and see why it grows exponentially.

• Recursion vs Iteration Side-by-Side

  

  Compare recursive and iterative solutions to the same problem running in parallel.

Chapter 8: Lists

• List Creation Visualizer

  

  Type comma-separated values and see them stored as indexed boxes in a Python list.

• List Indexing & Slicing Explorer

  

  Type index or slice expressions and see which list items are selected with visual highlighting.

• List Methods Playground

  

  Experiment with append, insert, remove, pop, sort, and reverse on a visual list.

• Nested List Grid Visualizer

  

  Click cells in a grid to see double-index notation for accessing nested list elements.

• List Traversal Animator

  

  Step through a for loop and watch the pointer move through each list element.

• Zip Function Visualizer

  

  Watch zip() pair elements from multiple lists together with an animated zipper metaphor.

Chapter 9: Advanced List Operations

• List Aliasing Visualizer

  

  See how variable names map to list objects in memory and discover the difference between aliases and copies.

• Shallow vs Deep Copy Visualizer

  

  Compare shallow and deep copies side by side and see how changes to nested elements propagate differently.

• List Statistics Dashboard

  

  Enter or generate a list of numbers and see len, min, max, sum, and average update in real time with a bar chart.

• Stack Simulator

  

  Push and pop items on an interactive stack to experience LIFO (Last In, First Out) behavior.

• Queue Simulator

  

  Enqueue and dequeue items to experience FIFO (First In, First Out) behavior, with a compare mode against a stack.

• List Operations Cheat Sheet

  

  Interactive reference for all advanced list operations organized by category with a Quiz Me mode.

Chapter 10: Tuples and Sets

• Tuple vs List Mutability

  

  Compare mutable list and immutable tuple behavior through interactive button operations.

• Tuples vs Lists Decision Helper

  

  Choose between tuples and lists for real-world coding scenarios with explanatory feedback.

• Set Operations with Venn Diagrams

  

  Visualize union, intersection, difference, and symmetric difference with interactive Venn diagram regions.

• Removing Duplicates with a Set

  

  Watch list values move into a set container, rejecting duplicates and converting back to a unique list.

• Tuple and Set Concept Map

  

  Explore relationships between lists, tuples, sets, and frozensets through interactive concept nodes.

Chapter 12: Classes and Objects

• Class vs. Object Visual

  

  Compare a class blueprint (cookie cutter) to multiple object instances (decorated cookies).

• Instance vs. Class Attributes

  

  Demonstrate the difference between attributes shared by a class and those unique to each instance.

• Dog Class UML Diagram

  

  Display the complete UML structure of a Dog class with attributes and methods.

• Encapsulation Bank Vault

  

  Use a bank vault metaphor to explain encapsulation and data protection in OOP.

• Dog Class Playground

  

  Create Dog objects, call methods, and observe output in an interactive console.

• OOP Benefits Concept Map

  

  Explore five key benefits of Object-Oriented Programming through interactive concept nodes.

Chapter 13: Inheritance and Polymorphism

• Animal Class Hierarchy

  

  Show inheritance relationships between parent and child animal classes.

• Shape Hierarchy with Abstract Base Class

  

  Demonstrate abstract base classes and inheritance in a shape hierarchy.

• Dunder Methods Cheat Sheet

  

  Reference guide for Python's special double-underscore methods.

• UML Class Diagram Builder

  

  Interactively build and explore UML class diagrams.

• Music Library Class Diagram

  

  Model a music library system with class relationships and structure.

• Polymorphism Playground

  

  Explore polymorphism through interactive demonstrations of method overriding.

Chapter 14: Errors and Exceptions

• Error Type Identifier

  

  Identify and classify different Python error types from code examples.

• Three Types of Errors

  

  Compare syntax errors, runtime errors, and logic errors with examples.

• Python Exception Hierarchy

  

  Visualize the inheritance tree of Python exception classes.

• Try-Except Block Builder

  

  Construct and understand try-except error handling blocks interactively.

• Try-Except-Finally Flow Chart

  

  Trace execution flow through try, except, and finally blocks.

• Exception Handling Simulator

  

  Simulate exception handling scenarios and predict their outcomes.

Chapter 15: File Input and Output

• File I/O Flow

  

  Visualize the flow of file input/output operations.

• Read Methods Comparison

  

  Compare different file reading methods and their effects.

• With Statement vs Manual Close

  

  Show the difference between context managers and manual file closing.

• CSV File Structure

  

  Understand how CSV files organize data in rows and columns.

• JSON to Dictionary Mapping

  

  See how JSON data maps to Python dictionaries.

• File Format Decision Tree

  

  Choose appropriate file formats based on data characteristics.

Chapter 16: Software Engineering

• Software Development Lifecycle

  

  Trace the phases of software development from conception to deployment.

• Module and Package Structure

  

  Explore how Python modules and packages are organized.

• Git Workflow Visualizer

  

  Visualize Git operations and version control workflow.

• DRY vs. WET Code Comparison

  

  Compare Don't Repeat Yourself principles with code repetition examples.

• Comment Quality Checker

  

  Evaluate and improve code comment quality.

• Name Equals Main Simulator

  

  Demonstrate the purpose and behavior of the if __name__ == '__main__' pattern.

Chapter 17: Testing and Debugging

• Unit Test Runner

  

  Run and visualize unit test execution and results.

• Boundary Testing Playground

  

  Test edge cases and boundary conditions in software.

• TDD Cycle

  

  Walk through the Test-Driven Development cycle of red-green-refactor.

• Visual Debugger Simulator

  

  Step through code execution with visual variable state tracking.

• Debugging Strategy Flowchart

  

  Decision flowchart to select appropriate debugging strategies.

• Input Validation Tester

  

  Test input validation logic and error handling.

Chapter 18: Searching and Sorting

• Linear Search Flowchart

  

  Visualize the control flow of linear search from first element to match or not found.

• Linear Search Step-by-Step

  

  Step through linear search one index at a time to see comparisons and stopping conditions.

• Binary Search Step-by-Step

  

  Follow midpoint checks and interval halving to understand binary search decisions.

• Sorting Algorithm Race

  

  Compare sorting algorithms side by side on the same data to observe speed differences.

• Big-O Growth Rate Chart

  

  Explore how runtime classes grow as input size increases.

• Choosing a Search or Sort Algorithm

  

  Use a decision flowchart to choose suitable search and sorting approaches by context.

Chapter 19: Algorithm Analysis

• Complexity Class Comparison Chart

  

  Compare O(1), O(log n), O(n), O(n log n), O(n^2), and O(2^n) with dynamic operation counts.

• Operation Counting Walkthrough

  

  Trace algorithm steps and count operations to connect code execution with Big-O reasoning.

• Strategy Comparison Diagram

  

  Contrast brute force, divide and conquer, and greedy strategies with use cases and tradeoffs.

• Sliding Window Visualization

  

  Watch a fixed-size window move across an array while updating sums incrementally.

• Recursion Tree for power(2, 8)

  

  Step through recursive calls and returns in fast exponentiation.

• Algorithm Visualization: Sorting Comparison MicroSim

  

  Compare selection, insertion, and merge sort progression frame-by-frame.

Chapter 20: Advanced Python

• Generator vs List Memory

  

  Compare eager list allocation with lazy generator evaluation through side-by-side memory usage visuals.

• How Decorators Work

  

  Step through how a decorator receives a function, creates a wrapper, and intercepts calls.

• Regex Pattern Tester

  

  Enter regex patterns and test text with real-time match highlighting and example presets.

• Collections Module Overview

  

  Explore Counter, defaultdict, OrderedDict, and namedtuple with expandable cards and quiz mode.

• Context Manager Flow

  

  Trace normal and exception paths in a with statement to see why cleanup always runs.

• Python Best Practices Checklist

  

  Evaluate code snippets against a best-practices checklist and score your assessments.