Industrial Engineer Information Processing cheat sheet

Cohesion measures how strongly related the responsibilities inside one module are; functional cohesion (single, well-defined task) is highest, coincidental cohesion (unrelated parts) is lowest.

Coupling measures interdependence between modules; design targets low coupling - data coupling (passing simple parameters) is weakest, content coupling (one module altering another's internals) is strongest.

Structured design maps a data flow diagram to a module structure: a transform-centered flow yields a control module calling input, transform, and output branches; a transaction-centered flow yields a dispatch module with one branch per transaction type.

UML relationships increase in strength: dependency < association < aggregation (shared, part can outlive whole) < composition (exclusive, part dies with whole) < generalization/inheritance.

SOLID: Single responsibility, Open-closed (extend without modifying), Liskov substitution (subtypes replaceable for supertypes), Interface segregation (small client-specific interfaces), Dependency inversion (depend on abstractions, not concretions).

Fan-in is the number of modules calling a given module (reuse indicator); fan-out is the number of modules it calls (control complexity). High fan-in with low-to-moderate fan-out is preferred.

Design patterns by intent: creational (Singleton, Factory Method, Abstract Factory, Builder, Prototype), structural (Adapter, Bridge, Composite, Decorator, Facade, Proxy), behavioral (Observer, Strategy, Command, State, Template Method, Visitor).

Architectural styles: layered (strict dependency between adjacent layers), client-server, MVC (model=data, view=presentation, controller=input handling), pipe-and-filter, event-driven/publish-subscribe, and microservices (independently deployable services).

Information hiding (Parnas) hides design decisions likely to change behind interfaces; abstraction separates interface from implementation, so a change in representation does not propagate to callers.

Black-box testing derives cases from the specification: equivalence partitioning (one case per valid/invalid class), boundary value analysis (min-1, min, min+1, max-1, max, max+1), and decision tables for rule combinations.

White-box coverage strength order: statement < branch/decision < condition < decision-condition (multiple condition) < path coverage; branch coverage subsumes statement coverage.

Cyclomatic complexity V(G) = E − N + 2 (edges − nodes + 2) = number of predicate decisions + 1 = number of bounded regions in the flow graph; it equals the minimum number of independent paths to test.

Integration strategies: top-down (uses stubs for lower modules), bottom-up (uses drivers for upper modules), sandwich/hybrid, and big-bang (no incremental order, hardest to isolate faults).

Regression testing re-runs existing test cases after a change to confirm nothing previously working broke; it is the primary safety net for iterative and agile delivery.

V-model pairs each development phase with a test level: requirements→acceptance test, design→system test, detailed design→integration test, coding→unit test.

Agile/Scrum: product backlog, sprint backlog, timeboxed sprint, daily scrum, sprint review (inspect the increment), sprint retrospective (inspect the process); velocity = story points completed per sprint.

Maintenance categories (ISO/IEC 14764): corrective (fix defects), adaptive (respond to environment change), perfective (improve performance or maintainability), preventive (reduce future deterioration).

Refactoring changes internal structure without changing external behavior; it is applied under a green test suite to keep behavior verifiable.

Normalization: 1NF removes repeating groups (atomic values); 2NF removes partial dependencies on part of a composite key; 3NF removes transitive dependencies on non-key attributes; BCNF requires every determinant to be a candidate key.

Functional dependency X→Y: X determines Y. Armstrong's axioms are reflexivity (if Y⊆X then X→Y), augmentation (X→Y implies XZ→YZ), and transitivity (X→Y and Y→Z imply X→Z).

Relational algebra: σ (selection, filters rows), π (projection, selects columns), ⨝ (join), × (Cartesian product), ∪, ∩, − (set operations), ρ (rename).

SQL execution order is logically FROM/JOIN → WHERE → GROUP BY → HAVING → SELECT → ORDER BY; WHERE filters rows before grouping, HAVING filters groups after aggregation.

ACID: Atomicity (all-or-nothing), Consistency (constraints preserved), Isolation (concurrent transactions do not interfere), Durability (committed changes survive failure).

Concurrency anomalies and isolation: dirty read (reads uncommitted data), non-repeatable read (row changes between reads), phantom read (new rows match a re-executed predicate); READ COMMITTED prevents dirty reads, REPEATABLE READ prevents non-repeatable reads, SERIALIZABLE prevents phantoms.

Two-phase locking: a growing phase acquires locks, a shrinking phase releases them; no lock is acquired after the first release. Strict 2PL holds exclusive locks until commit, preventing cascading rollback.

Index design: a B+-tree index supports equality and range scans in O(log n); a hash index supports equality only; a composite index is usable when the query predicates form a leftmost prefix of the index columns.

ER-to-relational mapping: strong entity→table; 1:N relationship→foreign key on the N side; M:N relationship→separate junction table with both keys; multivalued attribute→separate table.

Deployment cutover strategies: direct (big-bang) changeover - cheapest, highest risk; parallel run - old and new systems run together, safest, doubles cost; phased - cut over module by module; pilot - one site first, then roll out.

Backup types: full (all data, resets archive bit), differential (all changes since last full, does not reset archive bit), incremental (all changes since last backup of any type, resets archive bit); restore needs the last full plus the latest differential, or the last full plus every incremental since.

RAID levels: RAID 0 striping (no redundancy), RAID 1 mirroring, RAID 5 block striping with distributed parity (survives one disk failure, usable capacity = (n−1)×disk), RAID 6 dual parity (survives two failures), RAID 10 mirror plus stripe.

MTBF is mean time between failures; MTTR is mean time to repair; availability = MTBF / (MTBF + MTTR). Raising MTBF or lowering MTTR raises availability.

ITIL 4 incident management restores normal service as fast as possible (workaround allowed); problem management finds and removes root cause; change enablement authorizes changes through a change advisory board.

Service level agreement (SLA) records agreed service targets (uptime, response time, recovery time); RTO is the maximum tolerable downtime, RPO is the maximum tolerable data loss measured in time.

Configuration management keeps a configuration management database (CMDB) of configuration items and their relationships so that changes and incidents can be traced to affected components.

Performance metrics: throughput (transactions per unit time), response time (end-to-end latency), utilization (busy time / total time); Little's law: average number in system = arrival rate × average time in system.

CIA triad: confidentiality (only authorized disclosure), integrity (only authorized modification), availability (timely authorized access); non-repudiation and authenticity are supporting properties.

Symmetric ciphers (AES, DES/3DES) use one shared key and are fast for bulk data; asymmetric ciphers (RSA, ECC) use a public/private key pair and are slow, so they are used for key exchange and digital signatures.

A digital signature is a hash of the message encrypted with the sender's private key; the receiver verifies with the sender's public key, giving integrity, authenticity, and non-repudiation but not confidentiality.

Hash functions (SHA-256) are one-way and collision-resistant; they provide integrity, not confidentiality. A MAC (e.g., HMAC) adds a shared secret key to a hash to authenticate the message.

Public key infrastructure: a certificate authority signs an X.509 certificate binding a public key to an identity; the receiver validates the chain of trust and checks revocation via CRL or OCSP.

Access control models: DAC (owner grants access), MAC (labels and clearances, e.g., Bell-LaPadula no read up / no write down), RBAC (permissions assigned to roles), ABAC (attributes and policies).

Risk analysis: risk = likelihood × impact; residual risk remains after controls; risk treatment options are mitigate, transfer (insurance), avoid, and accept.

Common web attacks: SQL injection (defeated by parameterized queries), XSS (output encoding and CSP), CSRF (anti-CSRF tokens, SameSite cookies), and buffer overflow (bounds checking, ASLR, DEP).

BCP vs DRP: business continuity planning keeps critical business functions running during disruption; disaster recovery planning restores IT infrastructure after a disaster, driven by RTO and RPO.