OS
OpenStem
@openstem · Joined Jul 2026
7420 public items8 groups
Collection3 items
01Software · L5 · Compiler Construction Theory
02Software · L5 · Compiler Construction Theory
03Software · L5 · Compiler Construction Theory
Software · L5 · Compiler Construction Theory
@openstem
Software · L5 · Compiler Construction TheoryFlashcards5 cards
What is a computer?1 / 5
A computer is a machine that follows instructions. It can store, find, and use information very fast.
Software · L1 · What Is a Computer?
@openstem
Software · L1 · What Is a Computer?Flashcards5 cards
What is an algorithm?1 / 5
An algorithm is a list of steps you follow to finish a task. A recipe is a great example — it tells you exactly what to do.
Software · L1 · Algorithms: Step-by-Step Instructions
@openstem
Software · L1 · Algorithms: Step-by-Step InstructionsFlashcards10 cards
Explain the difference between == and === in JavaScript.1 / 10
`===` is strict equality — compares value AND type with no coercion. `==` is loose equality — coerces operands to a common type first (`0 == ""` is true). Always prefer `===`.
Fundamentals
@openstem
FundamentalsFlashcards10 cards
What is logged?1 / 10
false — floating-point rounding makes 0.1 + 0.2 = 0.30000000000000004.
Types & Coercion
@openstem
Types & CoercionFlashcards10 cards
What is destructuring assignment?1 / 10
Syntax to unpack values from arrays or properties from objects into variables. `const {a, b} = obj` and `const [x, y] = arr`. Supports defaults and renaming: `const {a: renamed = 0} = obj`.
ES6+ Features
@openstem
ES6+ FeaturesFlashcards10 cards
What is TypeScript and what problem does it solve?1 / 10
TypeScript is a statically typed superset of JavaScript that compiles to plain JS. It catches type errors at compile time rather than runtime, makes refactoring safer, and improves IDE support through autocompletion and inline docs.
Types & Inference
@openstem
Types & InferenceFlashcards10 cards
What are the primitive types in TypeScript?1 / 10
`string`, `number`, `bigint`, `boolean`, `symbol`, `null`, and `undefined`. These map directly to JavaScript primitives. TypeScript also adds `never`, `unknown`, `any`, and `void` as special types.
Everyday Types
@openstem
Everyday TypesFlashcards9 cards
What is the difference between a list and a tuple?1 / 9
Lists are mutable (modifiable in place) and use more memory. Tuples are immutable and hashable, so they can be dict keys or set members. Use tuples for fixed records, lists for collections you need to mutate.
Core Types
@openstem
Core TypesFlashcards9 cards
What is a first-class function?1 / 9
Functions in Python are first-class objects — they can be assigned to variables, passed as arguments, returned from other functions, and stored in data structures.
Functions & Decorators
@openstem
Functions & DecoratorsFlashcards8 cards
Why do you need a stable `key` when rendering a list?1 / 8
Keys let React match elements between renders to reuse DOM nodes and preserve component state. Using array index as key breaks when items are reordered/inserted — state attaches to the wrong item.
Rendering & Reconciliation
@openstem
Rendering & ReconciliationFlashcards10 cards
What does JSX compile to?1 / 10
JSX is syntactic sugar for `React.createElement(type, props, ...children)` (or the new JSX transform's `_jsx`). The compiler converts angle-bracket syntax into nested function calls.
JSX & Components
@openstem
JSX & ComponentsFlashcards9 cards
What is time complexity O(log n) and which algorithms exhibit it?1 / 9
O(log n) means the work halves with each step. Binary search, balanced BST operations, and heap insert/extract all run in O(log n). Typically achieved by halving the problem size at each step.
Big-O & Complexity
@openstem
Big-O & ComplexityFlashcards8 cards
Implement cycle detection in a linked list.1 / 8
Floyd's Tortoise & Hare: advance slow by 1 and fast by 2. If they meet, there's a cycle. O(n) time, O(1) space.
Linked Lists
@openstem
Linked ListsFlashcards10 cards
What is the difference between SQL and NoSQL databases?1 / 10
SQL (relational): structured schemas, ACID transactions, joins. Good for complex queries and strong consistency. NoSQL (document, key-value, column, graph): flexible schemas, horizontal scaling, eventual consistency. Trade consistency/flexibility for scale.
Databases & Storage
@openstem
Databases & StorageFlashcards9 cards
What is the difference between REST and GraphQL?1 / 9
REST uses multiple fixed endpoints (one per resource); GraphQL uses a single endpoint where clients specify exactly the data they need. GraphQL avoids over-fetching and under-fetching but adds complexity. REST is simpler and has better HTTP caching.
APIs & Protocols
@openstem
APIs & ProtocolsFlashcards10 cards
What is the difference between INNER JOIN and LEFT JOIN?1 / 10
INNER JOIN returns only rows with matches in both tables. LEFT JOIN returns all rows from the left table, with NULLs for unmatched right-side columns. Use LEFT JOIN to keep rows that have no match.
Joins
@openstem
JoinsFlashcards10 cards
What does this query return?1 / 10
Each department and its employee count, but only departments with more than 5 employees. WHERE filters rows before grouping; HAVING filters the groups after aggregation.
Aggregation & Grouping
@openstem
Aggregation & GroupingFlashcards10 cards
What is the difference between `git merge` and `git rebase`?1 / 10
Merge creates a new merge commit preserving branch history. Rebase replays commits on top of another branch — rewrites commit history for a cleaner linear log. Never rebase shared/published commits.
Core Concepts
@openstem
Core ConceptsFlashcards10 cards
What does this command do?1 / 10
It initializes a new, empty Git repository in the current directory by creating a hidden .git folder that stores all version history and metadata.
Setup & Configuration
@openstem
Setup & ConfigurationFlashcards10 cards
What is the zero value in Go?1 / 10
Every type has a zero value used when a variable is declared without initialization: 0 for numbers, false for bool, "" for strings, and nil for pointers, slices, maps, channels, and interfaces. There is no 'uninitialized' state.
Fundamentals
@openstem
FundamentalsFlashcards10 cards
How does a `for` loop differ in Go from C-style languages?1 / 10
Go has a single `for` keyword that serves as for, while, and infinite loops. `for {}` is infinite, `for cond {}` is a while loop, and `for i := 0; i < n; i++ {}` is the classic three-clause form.
Syntax & Control Flow
@openstem
Syntax & Control FlowFlashcards10 cards
How do you declare an immutable vs mutable variable?1 / 10
`let x = 5;` is immutable by default; `let mut x = 5;` is mutable. Rust makes immutability the default to favor safety and clearer intent.
Rust Syntax & Basics
@openstem
Rust Syntax & BasicsFlashcards10 cards
What are the three rules of ownership in Rust?1 / 10
1) Each value has a single owner. 2) There can be only one owner at a time. 3) When the owner goes out of scope, the value is dropped (freed). This is how Rust guarantees memory safety without a garbage collector.
Ownership & Borrowing
@openstem
Ownership & BorrowingFlashcards10 cards
What is the difference between `==` and `.equals()` in Java?1 / 10
`==` compares references (whether two variables point to the same object) for objects, or values for primitives. `.equals()` compares logical equality and should be overridden for value comparison. Always use `.equals()` for Strings and objects.
Core Java
@openstem
Core JavaFlashcards10 cards
What is the difference between `&&` and `&` for booleans?1 / 10
`&&` is short-circuiting: it stops evaluating once the result is known (right side skipped if left is false). `&` always evaluates both operands. Use `&&` to guard against side effects like null checks.
Syntax & Control Flow
@openstem
Syntax & Control FlowFlashcards10 cards
What is the CSS box model?1 / 10
Every element is a box composed of content, padding, border, and margin (inner to outer). `box-sizing: border-box` makes width/height include padding and border — the common modern default that avoids surprising sizing.
CSS Layout
@openstem
CSS LayoutFlashcards10 cards
Why use semantic HTML elements?1 / 10
Elements like <header>, <nav>, <main>, <article>, <footer> convey meaning to browsers, screen readers, and search engines — improving accessibility and SEO over generic <div> soup. Assistive tech uses them for navigation landmarks.
HTML & Semantics
@openstem
HTML & SemanticsFlashcards10 cards
Is Node.js single-threaded?1 / 10
JavaScript execution in Node is single-threaded (one event loop), but I/O is handled asynchronously by libuv's thread pool and the OS. CPU-bound work blocks the loop; offload it to Worker Threads or child processes.
Core & Event Loop
@openstem
Core & Event LoopFlashcards10 cards
What is the difference between CommonJS and ES Modules?1 / 10
CommonJS (require/module.exports) is synchronous and was Node's original system. ES Modules (import/export) are the standard, support static analysis and tree-shaking, and are asynchronous. Node supports both; .mjs or "type":"module" enables ESM.
Modules & Packages
@openstem
Modules & Packages