Ruankao System Analyst (Senior) key terms

A processor technique that overlaps execution of several instructions by splitting work into stages, so a new instruction enters each stage every cycle, raising throughput though each instruction's latency stays roughly the same.

A protocol set that keeps multiple processor caches showing one consistent view of shared memory, invalidating or updating stale copies when a core writes, so parallel programs observe correct values.

A formula bounding speedup from parallelising a program: the serial fraction limits total gain regardless of processor count, so scaling efforts should target the largest non-parallel portion first.

A multiprocessor memory layout where each processor has local memory with faster access and can reach remote memory more slowly, so operating systems and applications must place data near the threads that use it.

Two instruction-set philosophies: RISC uses few simple fixed-length instructions suited to pipelining, while CISC offers many complex variable-length instructions that do more per instruction but complicate decoding.

A design that issues several independent instructions per clock cycle using multiple execution units and dynamic scheduling, exploiting instruction-level parallelism beyond what a single pipeline achieves.

Distributing work across servers, processors, or nodes so no single resource is saturated, typically via round-robin, least-connection, or hashing algorithms, improving responsiveness and resilience.

Adding more machines or instances to share load rather than upgrading one machine, which improves capacity and fault tolerance but demands stateless design or shared state management.

Two quality measures for module design: cohesion is how strongly a module's internal parts belong together, coupling is how much modules depend on each other; good design seeks high cohesion and low coupling.

An iterative approach delivering working software in short increments, guided by close customer collaboration, responding to change, and continuous feedback rather than exhaustive up-front specification.

An agile method organising work into fixed-length sprints with defined roles (product owner, scrum master, team), artefacts (product and sprint backlogs), and ceremonies including planning, daily standup, review, and retrospective.

A practice where developers merge code frequently into a shared repository, each merge triggering automated build and tests, so integration defects surface early and releases stay reliable.

A culture and toolchain that unites development and operations so software is built, tested, deployed, and monitored through automated pipelines with shared responsibility for production reliability.

The ability to link each requirement forward to design, code, and tests and backward to its source, supporting impact analysis, coverage verification, and change control throughout the lifecycle.

A structured description of interactions between an actor and a system that together deliver an observable goal, capturing main flow, alternate flows, preconditions, and postconditions.

A ranking scheme sorting requirements into Must have, Should have, Could have, and Won't have this time, helping stakeholders agree scope and sequence when time or budget is fixed.

A conceptual diagram of the key business entities, their attributes, and their relationships, independent of implementation, used to align analysts and stakeholders before detailed design.

An arrangement where software is divided into horizontal layers, each offering services to the layer above and using the layer below, isolating concerns such as presentation, business logic, and persistence.

A style decomposing an application into small independently deployable services communicating over networks, each owning its data and lifecycle, trading simplicity for scalability and team autonomy.

A named, reusable solution to a recurring design problem in a given context, describing participating classes and their collaborations, such as Observer, Factory, or Strategy.

A stepwise process organising relations to remove redundancy and update anomalies by applying rules such as first, second, and third normal form, trading some join cost for integrity.

Four guarantees for reliable transactions: atomicity (all or nothing), consistency (valid state transitions), isolation (concurrent transactions do not interfere), and durability (committed changes survive failure).

A distributed-systems principle stating that during a network partition a system can guarantee either consistency or availability, not both, so architects choose trade-offs per workload.

A weaker consistency model where replicas may briefly diverge but converge given no new updates, common in highly available distributed stores that favour availability over immediate agreement.

An auxiliary data structure, often a B-tree or hash, that speeds lookups on specified columns at the cost of extra storage and slower writes, so indexes should match query patterns.

A seven-layer conceptual framework (physical, data link, network, transport, session, presentation, application) that separates networking concerns and helps reason about protocols and devices.

The practical internet protocol stack: IP handles addressing and routing, TCP provides reliable ordered streams, and UDP offers lightweight datagrams, with application protocols layered above.

Dividing a network address range into smaller logical subnets using a mask, improving traffic control, security segmentation, and efficient address allocation across sites.

The policies, roles, and systems that issue, distribute, and revoke digital certificates, binding public keys to identities so parties can authenticate each other and establish encrypted channels.

A cryptographic value computed over a message with a private key and verified with the matching public key, proving origin and integrity and providing non-repudiation.

A security strategy layering independent controls (network, host, application, data, people) so that failure of one barrier does not expose the whole system.

A scheduling technique identifying the longest dependent chain of tasks, whose duration sets the minimum project length; delays on that chain directly delay delivery.

A performance measurement method comparing planned value, earned value, and actual cost to compute schedule and cost variances and forecasts, giving early warning of overruns.

A living record of identified risks with likelihood, impact, owner, response strategy, and status, reviewed regularly so threats and opportunities are managed rather than discovered late.

The average amount of work a team completes per iteration, measured in story points or similar units, used to forecast delivery and guide release planning.

Packaging an application with its dependencies into an isolated, portable unit that shares the host kernel, enabling consistent deployment and fast scaling across environments.

A central repository consolidating data from operational systems, structured for query and analysis, typically loaded through extraction, transformation, and scheduled refresh cycles.

A store holding raw data in native formats at scale, with schema applied on reading, supporting varied analytics but requiring governance to avoid becoming an unmanaged swamp.

A pipeline pattern that pulls data from sources, cleans and reshapes it to target schemas, then loads it into a warehouse or mart, often on a scheduled batch basis.