Learning Outcomes:

1. Install and verify Python 3.x on Windows/macOS/Linux by running python --version in a terminal.

2. Configure a code editor (VS Code or Replit) with Python extensions and interpreter settings to enable linting and code execution.

3. Create and organize a course workspace folder and .py files using clear, descriptive file names.

4. Run a Hello World program from both the editor and the command line to validate the toolchain.

5. Apply basic terminal commands (cd and ls/dir) to navigate to and execute Python files.

6. Document setup steps and record solutions for common installation errors such as PATH misconfiguration.

7. Adhere to safe computing practices by keeping software updated and avoiding untrusted downloads.

Learning Outcomes:

1. Declare and initialize variables of type int, float, str, and bool using meaningful, snake_case names.

2. Apply type conversion with int(), float(), str(), and bool() to prepare user input for computation.

3. Format and print output using f-strings and the format() method to produce readable results.

4. Manipulate strings using indexing, slicing, len(), and methods such as lower(), upper(), strip(), and split().

5. Differentiate valid from invalid identifiers and apply Python naming conventions consistently.

6. Predict and correct TypeError scenarios when combining incompatible data types.

7. Capture and validate user input with input(), including prompts and basic checks before conversion.

Learning Outcomes:

1. Compose multi-line scripts that combine input, computation, and output to solve small tasks such as unit conversion or tip calculators.

2. Enforce correct indentation and spacing to eliminate IndentationError and SyntaxError in scripts.

3. Trace code line-by-line to predict program state and output for given inputs.

4. Use the Python REPL to prototype expressions and verify small code snippets before adding them to scripts.

5. Employ comments and minimal docstrings to communicate program purpose and usage.

6. Execute Python scripts from the terminal using python filename.py and interpret error messages to fix issues.

7. Organize versions of programs with incremental saves to track progress and facilitate rollback.

Learning Outcomes:

1. Apply arithmetic operators (+, -, *, /, //, %, **) to compute results for numeric problems.

2. Evaluate expressions using comparison (==, !=, <, <=, >, >=) and logical operators (and, or, not) to form complex conditions.

3. Use assignment and augmented assignment operators (+=, -=, *=, /=) to update variables concisely.

4. Interpret and enforce operator precedence with parentheses to produce correct outcomes.

5. Construct boolean expressions from multiple requirements and test them with sample inputs.

6. Mitigate floating-point precision issues where relevant using round() for user-facing results.

7. Verify expression correctness by writing small test snippets and checking expected outputs.

Learning Outcomes:

1. Implement branching logic with if, elif, and else to handle alternative paths based on input or state.

2. Combine relational and logical operators to encode multi-criteria decisions cleanly.

3. Apply truthiness rules to simplify conditions involving empty strings, zero values, and empty collections.

4. Construct input validation routines that reject invalid entries and prompt users again until valid data is provided.

5. Refactor long condition chains into clearer forms using helper variables and early checks to improve readability.

6. Trace execution for given inputs to confirm the selected code path matches expectations.

7. Create decision tables and targeted test cases to cover all branches.

Learning Outcomes:

1. Construct counted loops with for and range() to repeat actions a given number of times.

2. Iterate over strings, lists, and dictionaries to process collections element-by-element.

3. Build condition-controlled loops with while to repeat until a condition changes.

4. Employ break, continue, and pass to manage loop control flow appropriately.

5. Accumulate totals, counts, and extrema (min/max) using loop variables.

Learning Outcomes:

1. Define functions with parameters and return values to encapsulate reusable logic.

2. Apply argument passing (positional and keyword) and default parameter values to simplify calls.

3. Determine and enforce variable scope, avoiding unintended use of global variables.

4. Decompose a problem into small functions using top-down design and stepwise refinement.

5. Write simple unit tests with assert statements to confirm function behavior on normal and edge inputs.

6. Document functions with clear docstrings that specify purpose, parameters, return values, and assumptions.

7. Trace the call stack across multiple function calls to diagnose incorrect outputs.

Learning Outcomes:

1. Create and index lists; retrieve and modify elements by position using valid indices.

2. Apply list methods append(), extend(), insert(), remove(), pop(), index(), count(), sort(), and reverse() to manage collections.

3. Slice lists to copy, extract ranges, and step through sequences for sampling or subsetting.

4. Differentiate aliasing from copying and create independent copies with slicing or list().

5. Build and process lists using for loops to filter, transform, and aggregate data.

6. Implement linear search and simple summary statistics (min, max, average) using lists.

7. Guard against ValueError and IndexError by checking preconditions such as membership and index bounds.

Learning Outcomes:

1. Construct tuples for fixed records and unpack multiple values from tuples in assignments and loops.

2. Create dictionaries; add, update, and delete key-value pairs using indexing, update(), and del.

3. Retrieve dictionary values safely using get() with default values to avoid KeyError.

4. Iterate over dictionary keys, values, and items to compute summaries and lookups.

5. Use sets to remove duplicates and perform membership tests with add(), remove(), union(), and intersection().

Learning Outcomes:

1. Differentiate syntax errors, runtime exceptions, and logical errors by reproducing and classifying examples.

2. Implement try/except blocks to catch and handle specific exceptions such as ValueError and ZeroDivisionError.

3. Use else and finally clauses to separate successful paths and cleanup actions in programs.

4. Raise exceptions intentionally with raise to signal invalid states in functions.

5. Validate and sanitize user input to prevent crashes and produce helpful error messages.

6. Refactor code to isolate risky operations and centralize error handling for clarity.

7. Evaluate program robustness by testing with invalid or extreme inputs and documenting outcomes.

Learning Outcomes:

1. Open, read, and write text files using with open(...) as f to ensure proper resource management.

2. Read files line-by-line and process structured records using split() or basic csv module usage.

3. Write formatted output and append logs to existing files without overwriting existing content.

4. Construct correct relative file paths and verify the current working directory programmatically.

5. Handle FileNotFoundError and PermissionError using try/except with user-friendly messages.

6. Serialize and deserialize simple data structures with the json module to persist lists and dictionaries.

7. Build a small utility that summarizes a text or CSV file and writes a report with counts and totals.

Learning Outcomes:

1. Set breakpoints and step through code in a debugger to inspect variables and control flow.

2. Author test cases and assertions to verify function behavior and catch regressions.

3. Apply PEP 8 style guidelines and run a linter or formatter to improve readability and consistency.

4. Refactor duplicate or overly long code blocks into smaller, named functions for maintainability.

5. Instrument code with targeted print or log statements to diagnose defects, then remove them for clean final code.

Learning Outcomes:

1. Decompose a real-world task into input, processing, and output components with explicit specifications.

2. Draft pseudocode and flowcharts to outline control flow and data operations before coding.

3. Select suitable data structures (lists, dictionaries, sets) and control structures to support the solution.

4. Plan test cases that include normal, boundary, and error inputs to guide development.

5. Implement the algorithm in Python incrementally, verifying each step with small tests.

6. Analyze the efficiency of loops qualitatively and simplify hotspots where possible for clarity and speed.

7. Evaluate solution correctness against requirements and revise the design as needed.

Learning Outcomes:

1. Implement a menu-driven console application (e.g., budget tracker or gradebook) using functions and loops.

2. Structure program files and functions to separate input/output, business logic, and data storage concerns.

3. Persist and load application data using text or JSON files with appropriate error handling.

4. Validate and sanitize all user inputs and provide clear prompts and feedback.

5. Employ lists, dictionaries, and sets to store, search, and update program data effectively.

6. Integrate create, read, update, and delete (CRUD) operations to manage records within the app.

7. Test the application with a predefined checklist and fix discovered defects before release.

Learning Outcomes:

1. Organize the project into folders and modules and include any required data files for easy setup.

2. Compose a README that states purpose, features, setup steps, and usage examples with sample inputs/outputs.

3. Annotate code with meaningful docstrings and comments that explain non-obvious decisions and assumptions.

4. Demonstrate the program in a short walkthrough, highlighting how requirements were met and how to use key features.

Learning Outcomes:

1. Classify problems as decision, search, optimization, or counting using concrete examples from everyday contexts.

2. Distinguish well-defined from ill-defined problems by checking clarity of inputs, outputs, and constraints.

3. Formulate precise problem statements that specify inputs, desired outputs, and success criteria.

4. Identify constraints and edge cases for a given problem and document them clearly.

5. Transform an ill-defined problem prompt into a well-defined computational problem specification.

6. Map real-world scenarios (e.g., route planning, scheduling) to appropriate computational problem categories and justify choices.

7. Justify a chosen problem classification with written reasoning and counterexamples.

8. Select appropriate evaluation metrics (correctness, speed, memory) for judging candidate algorithms.

Learning Outcomes:

1. Construct structured pseudocode for simple algorithms using clear control structures and consistent indentation.

2. Trace algorithm execution step-by-step on sample inputs, recording variable states at each step.

3. Design flowcharts that accurately represent control flow for selection, loops, and function calls.

4. Validate algorithm preconditions and postconditions through targeted test cases.

5. Debug logic errors in pseudocode or Python by isolating failing steps and correcting control flow.

6. Compare pseudocode, flowcharts, and Python code to articulate equivalences and trade-offs in clarity.

7. Document edge cases and expected behavior for inputs at boundaries (empty lists, duplicates, extremes).

8. Refactor verbose pseudocode into more efficient versions while preserving correctness.

Learning Outcomes:

1. Define constant, logarithmic, linear, n log n, quadratic, and cubic time using Big O notation.

2. Order common growth functions and rank example algorithms by asymptotic efficiency.

3. Estimate operation counts for simple code fragments and simplify expressions using Big O rules.

4. Differentiate worst-case, average-case, and best-case analyses with concrete scenarios.

5. Compute Big O complexity for straight-line code, single loops, and simple conditional branches.

6. Visualize growth behaviors by plotting synthetic runtimes and interpreting the curves.

7. Select the more efficient of two algorithms for large inputs using asymptotic reasoning.

8. Explain the practical meaning of asymptotic analysis for real datasets and hardware limits.

Learning Outcomes:

1. Analyze time complexity of single and nested loops by counting dominant operations.

2. Derive simple recurrences for recursive algorithms (e.g., binary search, merge steps) and estimate their growth via recursion trees.

3. Compute logarithmic, linear, and quadratic patterns from code samples and justify results.

4. Trace binary search on sorted arrays and relate the halving process to O(log n).

5. Compare iterative and recursive implementations for clarity, time, and space trade-offs.

6. Instrument Python code to count iterations or comparisons and validate theoretical analysis.

7. Evaluate the impact of input size changes (doubling n) on execution counts for different complexities.

8. Diagnose off-by-one and base-case errors that affect correctness or complexity in recursive code.

Learning Outcomes:

1. Compute auxiliary space usage for algorithms using variables, arrays, and recursion stacks.

2. Differentiate input space from auxiliary space with annotated memory usage diagrams.

3. Analyze recursion depth and stack frame growth for common recursive procedures.

Learning Outcomes:

1. Implement Bubble Sort in Python with and without an early-exit optimization flag.

2. Trace Bubble Sort pass-by-pass on small arrays and record all swaps and comparisons.

3. Compute worst-case, average-case, and best-case time complexities for Bubble Sort using Big O.

4. Measure runtime on arrays of increasing size and visualize trends to confirm O(n^2).

5. Compare Bubble Sort to Python’s built-in Timsort on identical datasets and explain performance differences.

6. Design test datasets (sorted, reverse-sorted, nearly sorted, with duplicates) to probe behavior and stability.

7. Explain the stability and in-place properties of Bubble Sort and their practical implications.

8. Recommend appropriate and inappropriate use cases for Bubble Sort based on performance analysis.

Learning Outcomes:

1. Implement iterative and recursive binary search functions in Python that return index or not-found status.

2. Verify and enforce the precondition of sorted input using checks or pre-sorting routines.

3. Trace mid-point selections and interval updates on sample arrays until termination.

4. Analyze time complexity O(log n) and space complexity for iterative vs recursive versions.

5. Handle duplicates and not-found cases with clear return conventions and test coverage.

6. Compare binary search and linear search empirically by counting comparisons across input sizes.

7. Utilize Python’s bisect module to apply binary search patterns to real tasks (insertion points).

8. Benchmark search methods on large arrays and interpret results against theoretical expectations.

Learning Outcomes:

1. Decompose problems into subproblems, solve recursively, and combine results using structured pseudocode.

2. Implement a divide-and-conquer algorithm (e.g., Merge Sort or Max-Min) in Python and verify correctness.

3. Construct recursion trees to estimate time complexity and relate to known patterns (logarithmic, n log n).

4. Analyze overhead from splitting and merging and discuss base case design decisions.

5. Compare a divide-and-conquer solution to a straightforward iterative approach on performance and clarity.

6. Apply divide and conquer to a new context (e.g., closest pair on a grid or majority element) with guidance.

7. Evaluate trade-offs between recursion depth, stack usage, and performance for chosen problems.

Learning Outcomes:

1. Define the greedy choice property and optimal substructure using accessible examples.

2. Implement a greedy algorithm (e.g., activity selection or interval scheduling) and validate outputs.

3. Design a greedy solution for canonical coin change and test where it succeeds and fails with non-canonical sets.

4. Justify or refute greedy correctness through counterexamples and informal proofs.

5. Compare greedy solutions with dynamic programming on the same problem for performance and optimality.

6. Apply a greedy heuristic to a simple scheduling or resource allocation scenario and evaluate outcomes.

7. Document assumptions that must hold for a greedy strategy to be valid.

Learning Outcomes:

1. Identify overlapping subproblems and optimal substructure in a recursive specification.

2. Convert a naive recursive solution (e.g., Fibonacci or Climbing Stairs) into memoized and tabulated DP.

3. Implement a tabulation-based DP for a small 0/1 knapsack or coin change variant and verify correctness.

4. Trace DP table filling order and reconstruct solutions from stored decisions when applicable.

Learning Outcomes:

1. Represent graphs using adjacency lists in Python for undirected and directed cases.

2. Implement BFS using a queue and DFS using recursion or an explicit stack, ensuring correct visitation tracking.

3. Trace traversal orders on sample graphs and draw BFS/DFS trees from a given start node.

4. Analyze time and space complexity of BFS and DFS as O(V + E) and relate to graph density.

5. Compare BFS and DFS in terms of data structures used, traversal order, and typical use cases.

6. Detect connectivity and count connected components using repeated traversals.

7. Select BFS or DFS for a given scenario and justify the choice in writing.

Learning Outcomes:

1. Apply BFS to find shortest paths in unweighted graphs and reconstruct paths from parent pointers.

2. Apply DFS to detect cycles and perform a topological sort on DAGs with verification checks.

3. Model grid mazes and social networks as graphs and solve reachability problems with appropriate traversals.

4. Design test graphs (sparse, dense, cyclic, acyclic) to evaluate algorithm behavior and performance.

5. Convert recursive DFS to iterative form to prevent stack overflow on deep graphs.

6. Evaluate memory behavior of BFS vs DFS on wide vs deep graphs and report findings.

7. Compose a mini-project that integrates BFS or DFS to solve a school-relevant problem (e.g., campus navigation).

Learning Outcomes:

1. Define abstract data type (ADT) and relate it to concrete data structures used in Python.

2. Describe characteristics, strengths, and limitations of lists, stacks, queues, trees, and graphs.

3. Classify common problems by the data access pattern they require (random access, LIFO, FIFO, hierarchical, network).

4. Create Python list variables and manipulate elements using indexing and slicing.

5. Apply Python list methods (append, extend, insert, remove, pop, index, sort) to modify collections.

6. Trace element positions before and after list operations to verify correctness.

7. Compare arrays and linked lists conceptually with respect to memory layout and access patterns.

8. Illustrate real-world analogies for each structure to support problem–structure matching.

Learning Outcomes:

1. Characterize insertion, deletion, traversal, and search operations across core data structures at a conceptual level.

2. Estimate time complexity for common list, stack, and queue operations using Big-O notation.

3. Measure execution time of Python list operations using time or timeit.

4. Interpret empirical timing results to validate complexity expectations.

5. Select iteration and search strategies that reduce operation costs for simple tasks.

6. Document operation choices and expected performance for a given micro-scenario.

Learning Outcomes:

1. Implement insertion, deletion, traversal, and linear search on Python lists using loops and built-in methods.

2. Write functions for common list tasks (deduplicate, count frequency, reverse) with clear docstrings.

3. Test list functions using assert statements or unittest to confirm correctness.

4. Analyze performance trade-offs between append/pop and insert/remove at index 0.

5. Debug off-by-one and index errors using print statements or a debugger.

6. Validate input and handle edge cases such as empty lists and missing items.

Learning Outcomes:

1. Construct a Stack class using a Python list and using collections.deque.

2. Implement push, pop, peek, size, and is_empty methods with appropriate error handling.

3. Demonstrate the LIFO principle by tracing operation sequences and expected outputs.

4. Apply stacks to solve problems such as parentheses balancing or undo/redo.

5. Evaluate time complexity of stack operations on list vs deque implementations.

6. Create unit tests that verify LIFO behavior and edge cases such as underflow.

Learning Outcomes:

1. Build a Queue class using collections.deque to support enqueue, dequeue, front, size, and is_empty.

2. Demonstrate the FIFO principle through step-by-step enqueues and dequeues with expected outcomes.

3. Simulate a real-world waiting line (e.g., cafeteria or printer queue) and collect simple metrics like queue length.

4. Contrast queue implementations using list vs deque and justify the preferred choice.

5. Handle edge cases such as empty dequeue attempts and capacity-limited queues.

6. Profile enqueue and dequeue operations to confirm constant-time behavior.

Learning Outcomes:

1. Define nodes, edges, root, parent, child, leaf, depth, height, and degree within tree structures.

2. Differentiate trees from graphs by identifying the absence of cycles and the presence of a single root.

3. Represent a simple tree using nested Python objects or dictionaries.

4. Draw tree diagrams to visualize hierarchical relationships for sample data.

5. Identify real-world scenarios that naturally map to trees (file systems, organization charts, taxonomy).

6. Explain how traversal orders (preorder, inorder, postorder, level-order) visit nodes.

Learning Outcomes:

1. Implement a Node and BinarySearchTree class in Python with insert and search methods.

2. Perform preorder, inorder, postorder, and level-order traversals and print visit sequences.

3. Compute size, height, and leaf count of a binary tree using recursion or queues.

4. Compare search behavior in balanced vs skewed BSTs using example datasets.

5. Detect and handle duplicate values according to a defined policy.

6. Evaluate time complexity for insert, search, and traversal operations in binary trees.

Learning Outcomes:

1. Build a directory explorer that prints folders and files using a tree traversal.

2. Construct and evaluate an arithmetic expression tree from an infix or postfix expression.

3. Justify choosing a tree over a list or dictionary for hierarchical data storage.

4. Implement a basic delete operation in a binary search tree and verify tree integrity after deletion.

5. Create tests to validate traversals and application-specific behaviors.

6. Document design decisions and limitations of the chosen tree representation.

Learning Outcomes:

1. Define vertices, edges, adjacency, degree, path, cycle, and connectivity for graphs.

2. Distinguish directed vs undirected and weighted vs unweighted graphs using concrete examples.

3. Construct graph representations using adjacency lists (dict of lists) and adjacency matrices (2D lists).

4. Choose an appropriate representation for a scenario based on expected operations and graph density.

5. Implement add_vertex and add_edge functions for both adjacency list and matrix representations.

6. Analyze space and time trade-offs between adjacency list and adjacency matrix.

Learning Outcomes:

1. Implement Breadth-First Search (BFS) using a queue to discover nodes by levels.

2. Implement Depth-First Search (DFS) iteratively or recursively to explore graph components.

3. Track visited nodes to prevent infinite loops and to compute reachable sets.

4. Find and print a path between two nodes using BFS parent pointers.

5. Detect cycles in undirected graphs using DFS and in directed graphs using a recursion stack or color marking.

6. Evaluate the time complexity of BFS and DFS in terms of vertices (V) and edges (E).

Learning Outcomes:

1. Model a social network with users and connections and query friend-of-friend recommendations.

2. Model a road map and perform simple shortest-path exploration using BFS on an unweighted graph.

3. Justify when to prefer a graph over a tree for representing networks with cycles or multiple connections.

4. Identify real-world directed acyclic graph (DAG) scenarios such as task dependencies or course prerequisites.

5. Outline topological ordering on a DAG and apply it to schedule a small set of tasks.

6. Present a brief written rationale for representation and algorithm choices in each case study.

Learning Outcomes:

1. Analyze problem requirements to identify key operations, data volume, and access patterns.

2. Compare candidate structures (list, stack, queue, tree, graph) against the identified requirements.

3. Select the most suitable structure and articulate at least two reasons for the choice.

4. Predict performance impacts of the selection using Big-O and practical considerations.

5. Create a decision table or flowchart to guide structure selection for common scenarios.

6. Review peer solutions and provide constructive feedback grounded in performance criteria.

Learning Outcomes:

1. Design fair micro-benchmarks to compare operations across structures using timeit.

2. Implement benchmark scripts for list insert/remove, deque appendleft/popleft, BST search, and BFS traversal.

3. Visualize results using simple text tables or plots to compare operation timings.

4. Interpret anomalies and account for Python implementation details when explaining results.

5. Recommend structure choices based on measured data and operation profiles.

6. Document methodology, results, and conclusions in a short technical report.

Learning Outcomes:

1. Design a small application (e.g., task manager, help-desk ticketing, or contact network) with clear data requirements.

2. Implement the core data operations using the chosen computational structure(s).

3. Write automated tests that validate insertion, deletion, traversal, and search behaviors.

4. Evaluate the solution against correctness, performance, and code readability criteria.

5. Justify the final structure selection in a brief presentation or report referencing benchmarks and complexity.

6. Reflect on limitations and propose next steps or optimizations for future iterations.

Learning Outcomes:

1. Define population, sample, variable, and parameter for a given real-world question.

2. Formulate a testable question and hypothesis connected to a school, community, or business scenario.

3. Differentiate observational from experimental studies and identify independent and dependent variables.

4. Design a basic sampling plan (random or stratified) suitable for the scenario and justify the choice.

5. Identify potential sources of bias (selection, measurement, confounding) and propose mitigation steps.

6. Draft a short survey or data-log with clear items, response scales, and collection procedures.

7. Implement a brief pilot data collection (mock or small sample) and record observations for refinement.

8. Explain privacy, consent, and ethical handling steps for any personally identifiable information.

Learning Outcomes:

1. Calculate mean, median, and mode for a dataset by hand and with spreadsheet functions.

2. Compute range, variance, and standard deviation for sample data using appropriate formulas.

3. Compare center and spread across two groups and justify which measures are most appropriate.

4. Detect outliers using IQR or z-scores and describe their impact on summary statistics.

5. Create and interpret a histogram or box-and-whisker plot to describe distribution shape.

6. Construct a five-number summary and relate it to variability and potential skew.

7. Interpret computed statistics in context to make a concise, evidence-based statement.

Learning Outcomes:

1. Import a CSV dataset into Microsoft Excel and Google Sheets without breaking column formats.

2. Standardize column headers, fix data types, and convert text to numbers or dates as needed.

3. Handle missing values by removing or imputing and document the chosen approach.

4. Apply basic data validation and conditional formatting to flag inconsistent entries.

5. Use AVERAGE, MEDIAN, MODE, VAR.S, STDEV.S, COUNTIF, and IF to compute quick checks.

6. Create an Excel Table or named range and use sort/filter to prepare data for analysis.

7. Document a simple data dictionary that defines each field and its units.

Learning Outcomes:

1. Match variable types (categorical vs numerical; time series) to an appropriate chart type (bar, line, scatter, histogram).

2. Apply clear titles, axis labels, units, and sources to every chart.

3. Adjust axis scales and categories to avoid distortion and support accurate comparisons.

4. Choose accessible color palettes and contrasts that highlight key data without distraction.

5. Reduce clutter by removing chartjunk and emphasizing relevant marks and labels.

6. Annotate peaks, dips, and important thresholds to guide the viewer’s attention.

7. Evaluate a chart for misleading elements and propose concrete design improvements.

Learning Outcomes:

1. Create bar, line, scatter, and histogram charts from tabular data using Insert Charts.

2. Add and format axis labels, titles, legends, and data labels to improve readability.

3. Add a linear trendline to a scatterplot and display the equation and R² on the chart.

4. Customize chart elements (gridlines, markers, colors, number formats) to clarify patterns.

5. Use Excel Tables or named ranges to build dynamic charts that update with new data.

6. Export charts as high-resolution images for use in documents or slide decks.

Learning Outcomes:

1. Create bar, line, scatter, and histogram charts using the Chart Editor.

2. Configure axis labels, titles, legends, and series formatting to improve clarity.

3. Add a linear trendline to a scatterplot and display the equation and R² when appropriate.

4. Apply themes and customize colors, markers, and gridlines to emphasize insights.

5. Publish or share charts via link and manage viewer permissions.

6. Embed charts into Google Slides and maintain live links for automatic updates.

Learning Outcomes:

1. Launch a Jupyter notebook locally or in Google Colab for interactive coding.

2. Import numpy, pandas, and matplotlib.pyplot and verify library versions.

3. Load a CSV from local storage, URL, or Google Drive into a pandas DataFrame.

4. Inspect datasets using head(), info(), describe(), and shape to understand structure and quality.

5. Select columns and filter rows using bracket notation, loc, and boolean conditions.

6. Handle missing values using dropna() and fillna() with documented choices.

Learning Outcomes:

1. Calculate mean, median, mode, variance, and standard deviation using pandas/numpy functions.

2. Implement a custom function to compute a weighted mean for a practical scenario.

3. Group data by a categorical variable with groupby() and compute aggregate statistics.

4. Generate frequency distributions and percentiles to summarize variable ranges.

5. Detect outliers using z-scores or IQR in code and flag affected records.

6. Explain the ddof parameter and select sample vs population variance appropriately.

Learning Outcomes:

1. Construct bar, line, and scatter plots with matplotlib, mapping columns to axes.

2. Label axes, add titles and legends, and set axis limits and tick intervals for clarity.

3. Annotate interesting points with text and arrows to highlight findings.

4. Style plots using marker types, colors, line styles, and figure size to improve readability.

5. Save figures to PNG or SVG with appropriate resolution for reports.

6. Overlay a regression line on a scatter plot using numpy.polyfit and plot for visual fit.

Learning Outcomes:

1. Build a scatterplot of two numerical variables and insert a linear trendline.

2. Display and interpret slope, intercept, and R² from the trendline output.

3. Use SLOPE(), INTERCEPT(), CORREL(), and FORECAST.LINEAR() to compute predictions.

4. Calculate residuals for each data point and create a residual plot to assess fit.

5. Evaluate model suitability by commenting on linearity, outliers, and R² in context.

6. Make and justify predictions for new inputs and compare them to actual outcomes when available.

Learning Outcomes:

1. Split data into training and testing sets using scikit-learn or stratified indexing when needed.

2. Fit a LinearRegression model and print coefficients and intercept with meaningful labels.

3. Compute and interpret R², MAE, and MSE on the test set to evaluate performance.

4. Plot the regression line with scatter data and visualize residuals to spot issues.

5. Explain the practical meaning of coefficient signs and magnitudes for the scenario.

6. Document the modeling workflow and results in a well-commented notebook with narrative cells.

Learning Outcomes:

1. Differentiate regression (numeric targets) from classification (categorical targets) using examples.

2. Encode a binary target and select simple numeric features suitable for a baseline model.

3. Fit a logistic regression classifier in scikit-learn and generate class probabilities and labels.

4. Evaluate model accuracy, precision, recall, and a confusion matrix on a test set.

5. Plot and interpret a basic ROC curve and AUC to compare classification thresholds.

6. Discuss appropriate use cases, limitations, and ethical considerations for classification models.

Learning Outcomes:

1. Frame a clear problem statement, audience, and success criteria for the analysis.

2. Summarize key statistics, visuals, and model results in concise, plain language.

3. Construct a short evidence-based narrative that links insights to a recommended action.

4. Identify limitations, assumptions, and potential risks that affect confidence in the recommendation.

5. Propose next steps for data collection, model refinement, or additional experimentation.

Learning Outcomes:

1. Assemble multiple charts and key metrics on a single sheet using an intentional layout grid.

2. Implement interactive filters or slicers to let viewers explore subsets of data.

3. Apply consistent fonts, colors, and number formats to improve readability and professionalism.

4. Write informative captions and footnotes that explain figures and data sources.

5. Share the report securely and gather peer feedback to iterate on clarity and impact.

Learning Outcomes:

1. Define virtualization and distinguish hypervisor-based versus container-based approaches using concrete examples.

2. Illustrate scalability versus elasticity with scenario-based diagrams that show when each is appropriate.

3. Diagram how resource pooling and multi-tenancy enable pay-as-you-go pricing models.

4. Explain the characteristics of on-demand self-service and measured service in cloud usage contexts.

5. Calculate a simple monthly cloud cost from provided usage data and pricing tiers.

6. Evaluate benefits and limitations of migrating a small school app from a single PC to the cloud using pros/cons.

Learning Outcomes:

1. Describe the shared responsibility model and partition security duties across IaaS, PaaS, and SaaS on a layered diagram.

2. Identify common cloud security controls (IAM, encryption at rest/in transit, backups) for a student project scenario.

3. Map data classification levels (public, internal, restricted) to appropriate storage options and access controls.

4. Analyze a basic threat scenario (lost credentials) and propose at least three mitigations.

5. Outline a simple backup and recovery plan using cloud storage versioning and snapshots.

6. Explain regions and availability zones and assess their impact on reliability and latency for a school app.

Learning Outcomes:

1. Differentiate IaaS, PaaS, and SaaS by control, customization, and management scope using a layered stack diagram.

2. Match common school or startup scenarios to the most appropriate service model with written justification.

3. Compare time-to-deploy, skill requirements, and maintenance effort across IaaS, PaaS, and SaaS.

4. Estimate relative costs for each service model given a simple workload description and assumptions.

5. Recommend a service model for a given app idea and defend the choice against two alternatives.

6. Identify vendor lock-in risks associated with each service model and propose mitigation strategies.

Learning Outcomes:

1. Compare public, private, hybrid, and multi-cloud by ownership, isolation, connectivity, and governance attributes.

2. Identify legal, data locality, and performance constraints that influence deployment model selection.

3. Design a basic network and data placement diagram for a hybrid-cloud school information system.

4. Justify deployment model choices for at least three distinct scenarios (ecommerce, healthcare, education).

5. Outline a migration path from on-premises to public or hybrid cloud with key milestones and checkpoints.

6. Prioritize risks (outages, vendor dependency, complexity) across deployment models and suggest mitigations.

Learning Outcomes:

1. Draft a reference architecture for a simple web app including compute, storage, database, and CDN components.

2. Select a service model and deployment model and justify choices using defined decision criteria.

3. Map user requests and data flows through the architecture with a labeled swimlane diagram.

4. Propose an auto-scaling and monitoring strategy suitable for variable student traffic patterns.

5. Calculate a rough monthly budget using public pricing and identify at least three cost-saving levers.

Learning Outcomes:

1. Explain decentralization and contrast it with centralized client–server models using concrete examples.

2. Describe how peer-to-peer networks propagate blocks and transactions across nodes.

3. Illustrate transparency and immutability using block headers and hash chaining on a simple diagram.

4. Differentiate public, private, and permissioned blockchains with platform examples and intended uses.

5. Summarize consensus mechanisms (Proof of Work, Proof of Stake) at a conceptual level and compare trade-offs.

6. Evaluate scenarios where blockchain adds value versus where a traditional database is more appropriate.

Learning Outcomes:

1. Demonstrate how public/private keys enable signing and verification using a step-by-step analogy.

2. Trace the lifecycle of a blockchain transaction from creation to confirmation with key checkpoints.

3. Distinguish addresses, wallets, and accounts and map their relationships in a diagram.

4. Analyze common security risks (key loss, phishing, malware) and propose safe key management practices.

5. Explain how cryptographic hashes ensure data integrity and detect tampering with examples.

6. Construct a simple Merkle tree example to show efficient verification of data inclusion.

Learning Outcomes:

1. Define smart contracts and articulate their benefits and limitations in real-world terms.

2. Compare Ethereum-style programmable blockchains with Bitcoin scripting for flexibility and risk.

3. Identify non-cryptocurrency applications (supply chain, identity, certificates) and outline on/off-chain data flows.

4. Evaluate the role of oracles and external data in smart contract reliability and security.

5. Analyze a simplified smart contract bug scenario and suggest safeguards (testing, audits, time locks).

6. Appraise platform selection criteria (community, tooling, cost, energy use) for a school project recommendation.

Learning Outcomes:

1. Analyze a cloud-based streaming or e-learning service to identify core components and scaling approaches.

2. Evaluate data security and privacy considerations for student accounts and content storage.

3. Estimate compute, storage, and network resource needs for a small class project using given assumptions.

4. Calculate approximate monthly cost for a chosen architecture and highlight at least three cost optimizations.

5. Assess the environmental impact of the design using publicly available energy/carbon proxies and assumptions.

6. Recommend governance practices (access control, logging, backups) for responsible cloud use in schools.

Learning Outcomes:

1. Analyze a supply chain provenance example to map how data is recorded on-chain and off-chain.

2. Evaluate privacy trade-offs between transparency and confidentiality and propose mitigation patterns.

3. Compare energy and resource implications of PoW versus PoS networks for a chosen application.

4. Identify regulatory, ethical, and accessibility considerations when deploying a blockchain solution.

5. Recommend whether to use blockchain for a given problem and justify with a decision matrix.

6. Outline a responsible-use policy addressing scams, volatility, and consumer protection for student projects.

Learning Outcomes:

1. Construct a criteria matrix (cost, security, scalability, maintainability, ethics) to compare cloud and blockchain options.

2. Score at least two solution architectures for a scenario using the matrix and explain the ranking.

3. Prioritize key risks and map them to mitigations and contingency plans for each option.

4. Draft an executive summary that communicates the recommended technology choice to non-technical stakeholders.

5. Reflect on societal implications, inclusivity, and sustainability of the chosen approach and document takeaways.

Learning Outcomes:

1. Elicit and document functional and non-functional requirements from a local club or hypothetical startup scenario.

2. Design a solution that leverages appropriate cloud services and/or blockchain components with clear rationale.

3. Select a service model and deployment model and support the choice with evidence-based reasoning.

4. Outline a basic security and privacy plan including identity, encryption, and backup strategies.

5. Estimate costs and resource implications, including a rough environmental impact note, for the proposed solution.

6. Develop a phased adoption roadmap with success metrics, checkpoints, and risk mitigation steps.

7. Produce a concise presentation and technical brief tailored to both technical and non-technical audiences.

8. Critique peer projects using a rubric and provide constructive, actionable feedback.

Learning Outcomes:

1. Analyze how online actions create persistent digital footprints across platforms and services.

2. Differentiate responsible versus irresponsible online behaviors using school and community scenarios.

3. Evaluate consequences of doxxing, cyberbullying, and plagiarism under school policies and local laws.

4. Apply netiquette standards to craft respectful communications for email, forums, and group chats.

5. Construct a personal digital citizenship code listing specific do’s and don’ts for daily technology use.

6. Identify stakeholders affected by a social media post and predict short- and long-term impacts.

7. Demonstrate proper attribution and licensing by citing sources and using Creative Commons correctly.

8. Document clear steps for reporting harmful content to platform moderators and trusted adults.

Learning Outcomes:

1. Interpret common Terms of Service clauses (license to content, acceptable use, termination, dispute resolution, arbitration) in plain language.

2. Map the rights and obligations established between a provider and a user for a selected app or platform.

3. Compare data collection, retention, and sharing statements across two privacy policies and summarize differences.

4. Explain consent, parental consent/age restrictions, and data subject rights using age-appropriate examples.

5. Evaluate risks and trade-offs of granting app permissions on mobile devices and propose safer alternatives.

6. Extract action items from a ToS (account deletion, data export, opt-out steps) and practice them on a test account.

7. Draft three clarifying questions to send to a provider about ambiguous or risky clauses.

8. Decide whether to accept or decline a ToS for a target use case and justify the decision with evidence.

9. Summarize how EULAs, open-source licenses, and Creative Commons licenses differ in freedoms and responsibilities.

Learning Outcomes:

1. Classify spyware, adware, ransomware, phishing, spear-phishing, vishing, and pharming by behavior and impact.

2. Deconstruct a phishing message to identify red flags in sender details, URLs, attachments, and tone.

3. Distinguish phishing from pharming using DNS manipulation and website spoofing examples.

4. Simulate an attack chain from lure to credential theft and data exfiltration using a safe classroom scenario.

5. Evaluate the potential impacts of each threat on individuals, schools, and small businesses.

6. Recommend layered defenses aligned to the CIA triad (confidentiality, integrity, availability).

7. Demonstrate verification of website authenticity using certificates, WHOIS lookups, and URL decoding.

8. Create a personal incident-response checklist for suspected account or device compromise.

Learning Outcomes:

1. Implement a password strategy using passphrases, unique credentials, and a reputable password manager.

2. Configure multi-factor authentication (MFA) on two services and document secure storage of backup codes.

3. Harden a browser by setting privacy controls, blocking third-party cookies, and managing extensions safely.

4. Secure a smartphone by reviewing app permissions, enabling screen lock, and updating the operating system.

5. Apply safe Wi‑Fi habits including hotspot use, HTTPS verification, and VPN when appropriate.

6. Set up automated backups to local and cloud locations and test a file restore successfully.

7. Demonstrate safe file handling by scanning downloads and verifying file integrity when feasible.

8. Configure basic router settings on a demo interface (change default admin password, enable WPA2/3).

9. Report a suspected security incident using the provided school or platform workflow.

Learning Outcomes:

1. Classify personal, sensitive, and public data using a provided rubric for school projects.

Learning Outcomes:

1. Analyze access, affordability, and skills dimensions of the digital divide using a 3A framework.

2. Interpret local or national statistics to identify underserved groups and quantify gaps.

3. Map school and community assets (libraries, labs, ISPs, NGOs) that influence digital access.

4. Evaluate educational, economic, and civic impacts of limited connectivity using case examples.

5. Compare urban, rural, and peri-urban connectivity challenges and constraints.

6. Explain how device quality, language, and accessibility features affect participation for diverse learners.

7. Prioritize barriers most affecting your community using a weighted criteria matrix.

8. Propose measurable indicators to track progress toward equitable access over time.

Learning Outcomes:

1. Design a short survey or interview protocol to assess access and skills gaps ethically.

2. Obtain informed consent and safeguard respondent privacy during data collection activities.

3. Collect and clean small-scale community data using spreadsheets and basic validation rules.

4. Visualize findings with charts and simple maps to reveal access and usage patterns.

5. Synthesize insights into personas representing different user groups’ needs and constraints.

6. Ideate solutions (device lending, community Wi‑Fi, training) and rank them by impact and effort.

7. Construct a one-page action plan with objectives, partners, budget outline, and timeline.

8. Present the plan to peers and incorporate feedback into a revised proposal.

9. Draft a brief message to a local stakeholder advocating for the proposed solution.

Learning Outcomes:

1. Differentiate data bias, algorithmic bias, and interaction bias with concrete computing examples.

2. Analyze a real case (e.g., facial recognition or hiring) to locate likely sources of bias.

3. Identify proxy variables that can encode sensitive attributes within datasets.

4. Evaluate harms to individuals and groups arising from biased systems using impact statements.

5. Contrast accuracy and fairness trade-offs using simple decision scenarios.

6. Explain accountability roles of developers, companies, regulators, and users in mitigating bias.

7. Formulate probing questions to interrogate a system’s fairness before adoption in school or business.

8. Outline ethical review steps a school or startup should follow when deploying new technology.

Learning Outcomes:

1. Audit a small dataset for representation gaps using frequency counts and cross-tabs.

2. Compute and compare simple outcome rates between groups to detect disparities.

3. Test a rule-based or simple ML demo and observe differential errors across groups.

4. Redesign labels or sampling to improve representation and reduce skew in the dataset.

5. Apply pre-processing mitigation (e.g., reweighting or balanced sampling) on the demo data.

6. Evaluate fairness and utility after mitigation using defined metrics and reflections.

7. Draft transparent documentation (data card or model card) summarizing scope, limits, and risks.

8. Recommend governance controls such as human-in-the-loop review and escalation paths.

9. Reflect on personal biases and commit two strategies to reduce their effect in teamwork.

Learning Outcomes:

1. Apply a structured framework (Stakeholders–Options–Consequences–Values) to resolve a technology dilemma.

2. Construct a decision matrix weighing risks, benefits, and legal constraints for a chosen tool.

3. Evaluate trade-offs when selecting apps for schoolwork, entrepreneurship, or activism contexts.

4. Draft an acceptable-use guideline for a student project team with clear enforcement steps.

5. Plan a response to a privacy breach scenario using your incident-response checklist.

6. Justify a ToS acceptance or rejection for a mission-critical tool based on evidence.

7. Role-play clear communication to notify affected users and guardians after an incident.

8. Commit to two measurable habits that improve your digital citizenship for the next month.

Learning Outcomes:

1. Compile a portfolio of artifacts (ToS analysis, phishing deconstruction, bias audit) demonstrating competence.

2. Design a one-page privacy and security checklist tailored for classmates at your school.

3. Produce an infographic or short video campaign promoting safe, fair, and inclusive tech use.

4. Present your community action plan to an external audience and capture structured feedback.

5. Revise your personal digital citizenship code based on course learning and feedback.

6. Evaluate your growth using a self-assessment rubric supported by evidence from your portfolio.

7. Draft a brief policy proposal for your school addressing one identified digital citizenship gap.

8. Coordinate with peers to schedule an outreach or training session for a club or community group.

9. Document next steps to sustain responsible tech practices over the next six months.

Learning Outcomes:

1. Explain the five stages of Design Thinking and sequence them for a given problem scenario.

2. Analyze a local community problem to differentiate symptoms from root causes.

3. Map stakeholders for a chosen problem using an influence–interest grid.

4. Formulate a clear, user-centered problem statement using a How Might We format.

5. Establish SMART success criteria and constraints for evaluating potential solutions.

6. Evaluate sample solutions against empathy, feasibility, and viability criteria.

Learning Outcomes:

1. Design an interview protocol with open-ended, unbiased questions for target users.

2. Conduct 2–3 empathy interviews and document observations ethically with consent.

3. Synthesize qualitative data using affinity mapping to surface themes and insights.

4. Construct at least two user personas capturing goals, pains, and behaviors.

5. Create a customer journey map highlighting key pain points and opportunities.

6. Apply privacy and data-ethics guidelines when collecting and storing user data.

Learning Outcomes:

1. Generate 20+ solution ideas using brainstorming and SCAMPER within time-boxes.

2. Prioritize ideas with a feasibility–impact matrix to select a prototype concept.

3. Sketch low-fidelity paper prototypes that illustrate core user flows.

4. Build a clickable wireframe using Canva or Figma to demonstrate key interactions.

5. Plan and run a 5-user hallway usability test and capture actionable feedback.

6. Iterate the prototype by implementing at least three improvements based on test results.

Learning Outcomes:

1. Articulate a problem–solution statement linking target user, need, and unique approach.

2. Draft a Value Proposition Canvas mapping customer jobs, pains, and gains to product features.

3. Define measurable assumptions that must be true for the solution to work.

4. Select a minimum viable product (MVP) scope that de-risks top assumptions first.

5. Evaluate problem–solution fit using interview or survey evidence and a simple scorecard.

6. Communicate the value proposition in one concise sentence tailored to different audiences.

Learning Outcomes:

1. Draft a survey with clear objectives, operationalized variables, and unbiased items.

2. Select appropriate question types (Likert, multiple choice, open-ended) to capture needed data.

3. Pilot the survey with 3–5 peers and revise items based on clarity and reliability checks.

4. Define a basic sampling plan that targets a representative set of respondents.

5. Plan and facilitate a 6–8 person focus group using a structured discussion guide.

6. Document focus group insights using verbatim quotes and thematic notes.

Learning Outcomes:

1. Implement the survey using Google Forms and monitor response rates professionally.

2. Import responses into Google Sheets or Excel and clean data using filters and validation.

3. Compute descriptive statistics (mean, median, mode, percentages) for key questions.

4. Visualize findings with bar charts, histograms, and cross-tab tables.

5. Analyze segments by age or role to identify priority customer groups.

6. Summarize insights in a one-page brief linking data to problem–solution fit.

Learning Outcomes:

1. Calculate TAM, SAM, and SOM using top-down or bottom-up methods with cited sources.

2. Build a competitor comparison matrix including features, pricing, and target users.

3. Map competitors on a positioning chart to reveal whitespace opportunities.

4. Identify at least three differentiators for the proposed solution and justify them.

5. Assess industry trends and constraints relevant to a high school venture context.

Learning Outcomes:

1. Formulate testable hypotheses in the format: If we do X, we expect Y metric.

Learning Outcomes:

1. Complete a Business Model Canvas that aligns with validated customer insights.

2. Compare subscription, freemium, transaction, and advertising revenue models for fit.

3. Select a primary revenue model and justify the choice using customer and cost data.

4. Identify key resources, activities, and partners required to deliver the solution.

5. Draft a basic operations plan covering sourcing, delivery, and customer support.

Learning Outcomes:

1. Calculate unit cost and contribution margin for the product or service.

2. Apply pricing methods (cost-plus, value-based, competitive) to set an initial price.

3. Build a break-even analysis and identify the sales volume required for profitability.

4. Evaluate sensitivity of profit to price and cost changes using what-if analysis.

5. Propose discounts or bundles and quantify their impact on margins.

Learning Outcomes:

1. Construct a 12-month operating budget covering revenue, expenses, and capital needs.

2. Create a simple cash flow statement showing inflows, outflows, and ending balance.

3. Forecast cash burn and runway and propose actions to avoid negative cash gaps.

4. Plan basic record-keeping using categories for income, COGS, expenses, and taxes.

5. Determine initial funding requirements and outline feasible funding sources.

Learning Outcomes:

1. Assemble an executive summary that states the problem, solution, market, and traction.

2. Write a market analysis section grounded in primary and secondary research.

3. Define the product or service features, roadmap, and IP considerations clearly.

Learning Outcomes:

1. Outline a 5–7 minute pitch using a proven structure (problem, solution, market, model, traction, team, ask).

2. Draft a compelling opening story that illustrates the user problem with evidence.

3. Design clean slides that apply visual hierarchy, contrast, and minimal text.

4. Integrate data visualizations and user quotes to substantiate claims.

5. Tailor the pitch content and ask to a chosen audience (e.g., school admin, local sponsor).

Learning Outcomes:

1. Rehearse the pitch to achieve clear articulation and a target time window.

2. Apply effective body language, eye contact, and vocal variety during delivery.

3. Manage Q&A by anticipating objections and preparing concise responses.

4. Coordinate team roles for speaking, demoing, and handling slides seamlessly.

5. Solicit, record, and categorize stakeholder feedback during and after sessions.

Learning Outcomes:

1. Plan and run a weekly team stand-up and retrospective to track progress and blockers.

2. Implement a shared file system with version control practices and clear naming.

3. Prioritize feedback using MoSCoW or similar methods to guide iterations.

4. Document pivots and rationale in a changelog linked to evidence.

5. Apply ethical standards for data use, attribution, and inclusivity in all materials.

Learning Outcomes:

1. Deliver the final pitch and demo to a live audience and meet timing targets.

2. Submit the complete business plan and financials as professional deliverables.

3. Evaluate peer teams using a rubric covering clarity, evidence, feasibility, and impact.