Optimization pattern reducing synchronization overhead.

Library loaded during program execution.

Linking libraries at runtime rather than statically.

Movement of data through program operations.

Analysis tracking how values move through code.

Concurrent access to shared data causing undefined or incorrect behavior.

Language expressing what should be achieved rather than how.

Analysis performed while software executes.

Principle favoring abstractions over concrete dependencies.

Principle stating high-level modules should depend on abstractions.

Principle encouraging avoidance of duplicated knowledge or logic.

Abbreviation for Don't Repeat Yourself.

Method used to clean up an object.

Class inheriting from another class.

Relationship where one component relies on another.

Passing responsibility to another object.

UI control displaying selectable options.

Window requesting input or displaying information.

Interface theme using predominantly dark colors.

Moving an item by dragging it.

Threads permanently waiting for each other.

Attack or condition preventing normal service.

Distributed attack overwhelming a service.

Cryptographic proof of authenticity and integrity.

Converting ciphertext back into readable data.

Assurance that data remains unaltered.

Protection against unauthorized disclosure.

Ensuring authorized access when needed.

Trying words from a prepared list.

Information useful in investigating digital activity.

Reusable solution to a common design problem.

System whose components run across multiple machines.

Adds behavior without modifying the original object.

Supplies dependencies from outside a component.

High-level code should not depend on concrete details.

Depend on abstractions rather than concrete implementations.

Avoid unnecessary duplication in code.