SE Gym – Lift Your Skills

Includes all quizzes taught until today

Includes all quizzes taught until today

Test your knowledge on software construction principles, design patterns, testing, security, and Git based on the CS 35L Final Exam.

Recalling what you just learned is the best way to form lasting memory. Use this quiz to test your understanding.

Apply layered architecture to real engineering decisions — diagnose violations, pick between strict and relaxed layering, handle upward notification, and judge when to invert dependencies.

Apply the pipes-and-filters style to design decisions — choose between pipelines and batch-sequential, diagnose violations of filter independence, judge when the style is the right call, and reason about error-handling trade-offs.

Apply the publish-subscribe style to real architectural decisions — choose between push and pull, diagnose coupling smells, pick QoS levels, and judge when pub-sub is the wrong tool.

Reason across architectural styles — choose the right style for a problem, distinguish styles from patterns, compare platonic and embodied forms, and design heterogeneous architectures that combine multiple styles coherently.

Apply availability and performance tactics to concrete quality-attribute scenarios.

Test your understanding of C — what's different from C++, how memory and the compilation pipeline actually work, and the design tradeoffs that motivate the language.

Test your ability to reason about ACID, CAP, and the RDBMS/NoSQL trade-off in realistic scenarios — not just recite definitions.

Apply, Analyze, and Evaluate-level questions on the four-step debugging process — distinguish fault / error / failure on real scenarios, pick the right tactic (logs vs debugger vs git bisect vs rubber duck) for the situation, and recognize when a fix isn't actually done.

Test your understanding of Command roles, refactoring triggers, undo, macro commands, null commands, and appropriate use.

Test your understanding of creational patterns — when to use which, design decisions, and their relationships.

Test your understanding of the Mediator pattern, its trade-offs, and its relationship to Observer.

Test your understanding of the MVC architectural pattern, its compound structure, and its modern variants.

Test your understanding of the Null Object pattern's intent, its relationship to Singleton/Strategy/State, when it applies, and the bug-masking risk it introduces.

Test your understanding of the Observer pattern's design decisions, trade-offs, and common pitfalls.

Test your understanding of the Singleton pattern's controversies, thread-safety mechanisms, and modern alternatives.

Test your understanding of the State pattern's design decisions, its relationship to Strategy, and the principle of polymorphism over conditions.

Test your understanding of the Strategy pattern's structure, its composition-over-inheritance principle, and the often-confused boundary with the State pattern.

Test your understanding of Adapter, Composite, and Facade — their distinctions, design decisions, and when to apply each.

Test your understanding of design-pattern selection, trade-offs, and design reasoning.

Test your ability to identify, apply, and evaluate the Information Hiding principle in real code.

Test your ability to identify, apply, and evaluate Separation of Concerns in real code.

Test your ability to apply and evaluate the five SOLID principles — with an emphasis on the Single Responsibility and Liskov Substitution Principles.

A comprehensive mix of the design-principles quizzes: Separation of Concerns, Information Hiding, SOLID, and Design with Reuse.

Test your ability to recognize, apply, and weigh design-with-reuse decisions in real software projects.

Recognize beacons, evaluate when they help or mislead, and apply beacon-based reading strategies in code review and education.

Apply code-comprehension research to realistic reading, review, architecture, and refactoring decisions.

Diagnose common code smells from realistic maintenance scenarios and choose proportionate refactoring responses.

Apply GenAI judgment across Bloom levels, with extra emphasis on analyzing, evaluating, and creating safe AI-assisted engineering workflows.

Apply modern code-review research to PR size, reviewer cognition, socio-technical dynamics, reviewable-code practices, Google-scale workflow, and AI-era review.

Apply refactoring concepts to behavior-preservation, smell diagnosis, safe process, and AI-assisted transformation scenarios.

Practice hypothesis-driven code reading, beacon recognition, layout critique, and strategic switching between top-down and bottom-up comprehension.

A comprehensive mix of the development-practices quizzes with standalone decks: comprehension, debugging, GenAI, review, code smells, refactoring, and beacons.

Test your understanding of the evidence-based study techniques.

Test your knowledge of core version control concepts, Git architecture, branching strategies, and advanced commands.

Test your knowledge of advanced Git commands, debugging tools, and integration strategies.

Test your knowledge of core version control concepts, Git architecture, branching, merging, and collaboration.

Apply, Analyze, and Evaluate-level questions on test design — diagnose weak assertions, choose appropriate inputs, recognize behavior-coupling, and pick the right oracle. Distractors target the misconceptions students actually hold.

Test your deeper understanding of Java's type system, OOP model, and design idioms. Covers false friends with C++/Python, encapsulation vs information hiding, generics, collections, and exception handling. Includes Parsons problems, technique-selection questions, and spaced interleaving across all concepts.

Test your understanding of Makefiles, including syntax rules, execution order, automatic variables, and underlying concepts like incremental compilation.

Test your understanding of network architectures, the TCP/IP protocol stack, HTTP, and how the internet works.

Given real-world application scenarios, choose the right network architecture, transport protocol, and application protocol. These questions test your ability to analyze trade-offs and justify design decisions.

Test your deeper understanding of JavaScript's async model, type system, and paradigm differences from C++ and Python. Includes Parsons problems, technique-selection questions, and spaced interleaving across all concepts.

Apply software-process thinking to real situations — choose between Waterfall and Agile for a given domain, judge what 'over' means in the Agile Manifesto, recognize Agile anti-patterns, and reason about iterative-vs-incremental delivery.

Apply XP practices to real team scenarios — choose between pair and solo work, judge when XP is the wrong fit, diagnose CI feedback-loop problems, navigate TDD-vs-design tension, and reason about collective ownership and bus factor.

Test your deeper understanding of Python's design choices, paradigm differences from C++, and when to use which tool.

Apply interoperability principles to real integration problems — diagnose semantic vs syntactic failures, write measurable interop requirements, choose adapter strategies, and balance variability against implementation effort.

Decide whether each statement is a usable quality-attribute requirement, then identify the smell or strength that matters.

Apply testability thinking to real code and architecture — diagnose controllability and observability problems, pick the right test double, recognize SOLID synergies, and judge when monkey vs metamorphic vs TDD is the right approach.

Apply quality-attribute thinking to real design decisions — write measurable requirements, reason about trade-offs and synergies, distinguish design-time from run-time qualities, and judge when to invest in non-functional concerns.

Practice identifying, specifying, prioritizing, and trading off quality attributes across realistic architecture scenarios.

Test your deeper understanding of React's design philosophy, state management, and component architecture. Questions 1–7 cover tutorial material. Questions 8–10 test advanced concepts from the reference page. Questions 11–15 cover event handlers, useEffect, and state immutability.

Test your understanding of regular expressions beyond basic syntax, focusing on underlying mechanics, performance, and theory.

Recalling what you just learned is the best way to form lasting memory. Use this quiz to test your ability to discriminate between problem-space statements (requirements) and solution-space statements (design) in novel scenarios.

Classify each statement by deciding whether it captures the required outcome or prematurely chooses an implementation.

Recalling what you just learned is the best way to form lasting memory. Use this quiz to test your understanding of the Scrum framework — its empirical pillars, accountabilities, artifacts, and events.

Test your ability to reason about the CIA triad, web vulnerabilities, cryptographic primitives, authentication, and security design principles in realistic scenarios — not just recite definitions.

Test your conceptual understanding of shell environments, data streams, and scripting paradigms beyond basic command memorization.

Arrange shell-pipeline fragments to filter, sort, count, and combine log and config files.

Test your understanding of architecture definitions, drivers, views, decisions, and degradation.

A comprehensive mix of the systems quizzes: networking fundamentals and decisions, data management, and security.

Apply, Analyze, and Evaluate-level questions on TDD — diagnose violations of the Three Rules, pick the simplest passing implementation, recognize when TDD doesn't fit, and identify the rhythm that produces TDD's real benefit.

Apply, Analyze, and Evaluate-level questions on the test-double taxonomy — pick the right double for a scenario, recognize Spy vs Mock by failure timing, and diagnose over-mocking that tests the mock instead of the SUT.

Apply, Analyze, and Evaluate-level questions on the core vocabulary of testing — regression, black-box vs. white-box, and choosing the right level of the testing pyramid.

Apply, Analyze, and Evaluate-level questions on whole-suite quality — coverage vs. oracle strength, mutation testing, flake diagnosis, oracle choice, and quality metrics.

A comprehensive mix of the standalone tools quizzes: shell, regular expressions, programming-language essentials, Git, Java, C, and Make.

Test your ability to read and interpret UML Class Diagrams.

Test your ability to read and interpret UML Component Diagrams.

Test your ability to read and interpret UML Sequence Diagrams.

Test your ability to read and interpret UML State Machine Diagrams.

Test your ability to read and interpret UML Use Case Diagrams.

Test your ability to identify which of the INVEST principles are being violated in various Agile user stories, now including their associated Acceptance Criteria.

Includes all flash cards taught until today

Includes all flash cards taught until today

Concepts, constraints, trade-offs, and modern evolutions of the layered architectural style — including the layers-vs-tiers distinction, the golden rule, and Clean/Hexagonal inversions.

Concepts, constraints, execution models, and trade-offs of the pipe-and-filter architectural style — including the sorting paradox, filter independence, and modern uses in compilers and data pipelines.

Key concepts, structural elements, subscription models, and trade-offs of the publish-subscribe architectural style.

Foundational vocabulary, taxonomy, and combination patterns for architectural styles — including style vs pattern, platonic vs embodied, heterogeneous architectures, and the styles taxonomy from data-flow to event-based.

Availability and performance tactics, including ping-echo, heartbeat, redundancy, and caching.

Cards span Remember through Create. Mix of definition recall, code prediction, design-decision reasoning, and small code-writing problems for spaced retrieval practice.

Retrieval practice for DBMS concepts, SQL, relational algebra, transactions, ACID, CAP, and NoSQL trade-offs.

Retrieval practice for the four-step debugging process — fault / error / failure vocabulary, reproduction tactics, when to use logs vs the debugger vs rubber-ducking, conditional breakpoints, and the discipline of verifying a fix. Cards span Remember through Evaluate.

Key roles, refactoring triggers, undo mechanics, and trade-offs of the Command design pattern.

Key concepts and comparisons for creational design patterns.

Key concepts, design decisions, and the Observer vs. Mediator comparison.

Key concepts for the Model-View-Controller architectural pattern and its compound structure.

Key concepts, roles, applicability, and trade-offs of the Null Object design pattern.

Key concepts, design decisions, and trade-offs of the Observer design pattern.

Key concepts, controversies, and modern alternatives for the Singleton design pattern.

Key concepts, design decisions, and trade-offs of the State design pattern.

Key concepts, design decisions, and trade-offs of the Strategy design pattern.

Key concepts for Adapter, Composite, and Facade patterns.

Core concepts, categories, and principles of design patterns in software engineering.

Key concepts, design decisions, and trade-offs for each individual GoF pattern covered in the course.

Key definitions, examples, trade-offs, design-doc practices, software-aging lessons, and common confusions around Information Hiding.

Key definitions, examples, trade-offs, and misconceptions of Separation of Concerns (SoC).

Definitions, misconceptions, and the deeper 'why' behind each SOLID principle — with extra depth on SRP and LSP.

A comprehensive mix of the design-principles flashcards: Separation of Concerns, Information Hiding, SOLID, and Design with Reuse.

Key definitions, principles, cases, and trade-offs for designing software with reuse.

Lexical, structural, test, assertion, architectural, and contextual beacons for expert code comprehension and review.

Cognitive load, mental models, comprehension metrics, architecture-code alignment, and practical strategies for making code easier to understand.

Common code smells, the design forces behind them, and the refactorings that usually address them.

Core concepts, productivity trade-offs, skill-formation risks, coding-agent safety, and best practices for using Generative AI in software engineering.

Formal inspections, modern asynchronous review, cognitive limits, socio-technical dynamics, reviewable code, Google-scale review, and AI-era review risks.

Semantic-preserving transformations, code smells, safe refactoring process, common refactorings, and AI-assisted refactoring supervision.

Hypothesis-driven code reading, beacons, schemas, stepdown structure, opportunistic switching, and tools that support top-down comprehension.

A comprehensive mix of the development-practices flashcards with standalone decks: comprehension, debugging, GenAI, review, code smells, refactoring, and beacons.

Which Git command would you use for the following scenarios?

Which Git command would you use for the following advanced scenarios?

Which Git command would you use for the following scenarios?

Retrieval practice for writing readable, trustworthy unit tests — the four-part shape, strong oracles, systematic input selection, determinism, behavior over implementation, and TDD rhythm. Cards span Remember through Create; many are scenario-based.

You are shown Java code. Go beyond naming what it does — explain *why* it behaves that way, what design choice it reflects, or what would break if it changed.

You are given a scenario or design problem. Write Java code that solves it. Questions target Apply, Evaluate, and Create levels — not just syntax recall.

Test your knowledge on solving common build automation problems using Makefile syntax and rules!

Test your ability to read and understand actual Makefile snippets commonly found in real-world C projects.

A comprehensive collection of Makefile syntax, example generation, and real-world C project snippets.

Test your ability to produce the exact Makefile syntax, rules, and variables based on their functional descriptions.

Review key networking concepts: architectures, protocols, HTTP, and the TCP/IP stack.

You are shown JavaScript/Node.js code. Explain what it does and what it outputs.

You are given a task description. Write the JavaScript code that accomplishes it.

Concepts, history, and trade-offs of software processes — Waterfall, Agile, the Manifesto, iterative-incremental development, and major Agile frameworks (Scrum, XP, Lean).

Concepts, practices, and trade-offs of Extreme Programming — the Agile framework that pushes good software-engineering practices to their purest form.

You are shown Python code. Explain what it does and what it returns or prints.

You are given a task description. Write the Python code that accomplishes it.

Concepts, syntactic vs semantic interoperability, design tactics, and trade-offs of the interoperability quality attribute.

Concepts, controllability/observability, test doubles, design tactics, and advanced techniques for the testability quality attribute.

Concepts, specification, trade-offs, and synergies of quality attributes — the non-functional 'how well' dimensions of a software system.

Broad review of quality attributes, measurable specifications, architectural trade-offs, tactics, and design-time versus run-time qualities.

You are shown React/JSX code. Explain what it does and what it renders.

You are given a task description. Write the React/JSX code that accomplishes it.

Test your ability to produce the exact Regular Expression metacharacter or syntax based on its functional description.

Test your knowledge on solving common text-processing problems using Regular Expressions!

Retrieval practice for the Scrum framework — empirical pillars, accountabilities, artifacts, values, and events. Cards span Bloom's taxonomy from recall through evaluation.

Retrieval practice for the CIA triad, SQL injection, XSS, cryptography (symmetric, public-key, signatures), authentication (sessions, JWT), and security design principles.

Which Shell command would you use for the following scenarios?

Match each shell command to its purpose

Practice connecting UNIX commands together with pipes to solve real tasks.

Definitions, architectural drivers, views, ADD, and architecture degradation.

Test your knowledge on evidence-based study techniques!

A comprehensive mix of the systems flashcards: networking, data management, and security.

Retrieval practice for TDD as a development rhythm — the Three Rules, Red-Green-Refactor, BUFD vs. evolutionary design, the Patterns-Happy malady, the Rocket Ship analogy, living documentation, and where TDD struggles. Cards span Remember through Evaluate.

Retrieval practice for the test-double taxonomy — SUT, DOC, indirect inputs vs outputs, the five kinds of double (Dummy, Fake, Stub, Spy, Mock), procedural vs expected-behavior verification, and how to choose. Cards span Remember through Evaluate.

Retrieval practice for the core vocabulary of software testing — regression, black-box vs. white-box, and the testing pyramid (unit, component, integration, system). Cards span Remember through Evaluate; scenario-based wherever possible.

Retrieval practice for evaluating a whole test suite — coverage vs. quality, oracle types, mutation testing, flakiness, test smells, and the quality rubric. Cards mix Remember, Understand, Apply, Analyze, and Evaluate.

A comprehensive mix of the standalone tools flashcards: shell, regular expressions, programming-language essentials, Git, Java, C, and Make.

Quick review of UML Class Diagram notation and relationships.

Quick review of UML Component Diagram notation and architecture-level modeling.

Quick review of UML Sequence Diagram notation and fragments.

Quick review of UML State Machine Diagram notation and transitions.

Quick review of UML Use Case Diagram notation and relationships.

Test your knowledge on Agile user stories and the criteria for creating high-quality requirements!