Reliable Programming

Flashcards generated from lecture notes on Reliable Programming, focusing on vocabulary terms and definitions.

Software Quality

Creating a high-quality product with useful features that people want to use, is reliable, and user-friendly.

Reliability

A product quality attribute ensuring the software does not crash or lose information.

Security

A product quality attribute focused on protecting the software and data from unauthorized access and threats.

Usability

A product quality attribute ensuring users can learn to use the software quickly and without mistakes.

Maintainability

A product quality attribute related to the ease with which software can be modified, updated, or repaired.

Responsiveness

A product quality attribute measuring how quickly the software reacts to user input.

Availability

A product quality attribute indicating the degree to which software is accessible and operational when required.

Resilience

A product quality attribute that describes a system ability to recover quickly from difficulties.

Fault Avoidance

A technique for reliability improvement by programming in such a way to avoid introducing faults into the program.

Input Validation

A technique for reliability improvement by defining the expected format for user inputs and validating that all inputs conform to that format.

Failure Management

A technique for reliability improvement by implementing software so that program failures have minimal impact on product users.

Coupling

The number of relationships between entities in a program. Higher coupling indicates a more complex system.

Static Relationship

A relationship between program components that is stable and does not depend on program execution.

Dynamic Relationship

A relationship between program components that changes over time and is more complex than static relationships.

Reading Complexity

Reflects how hard it is to read and understand the program.

Structural Complexity

Reflects the number and types of relationships between the structures (classes, objects, methods or functions) in a program.

Data Complexity

Reflects the representations of data used and relationships between the data elements in a program.

Decision Complexity

Reflects the complexity of the decisions in a program.

Single Responsibility Principle

Each class should have only one reason to change.

Abstraction

A simplified representation of something more complex, hiding unnecessary details.

Deeply Nested Conditional Statements

Conditional (if) statements that are nested within each other, making code harder to read and understand.

Inheritance

A feature of object-oriented programming where a class inherits attributes and methods from a superclass.

Design Pattern

A general reusable solution to a commonly-occurring problem within a given context in software design.

Separation of Concerns

Each abstraction in a program (class, method, etc.) should address a separate concern, and all aspects of that concern should be covered there.

Creational Patterns

Design patterns concerned with class and object creation.

Structural Patterns

Design patterns concerned with class and object composition.

Behavioral Patterns

Design patterns concerned with class and object communication.

Adapter Pattern

A structural design pattern used to match semantically-compatible interfaces of different classes.

Factory Pattern

A creational design pattern used to create objects when slightly different variants of the object may be created.

Prototype Pattern

A creational design pattern used to create an object clone, i.e. a new object with exactly the same attribute values as the object being cloned.

Facade Pattern

A structural design pattern used to provide a single interface to a group of classes in which each class implements some functionality accessed through the interface.

Mediator Pattern

A behavioral design pattern used to reduce the number of direct interactions between objects; all object communications are handled through the mediator.

State Pattern

A behavioral design pattern used to implement a state machine where the behavior of an object changes when its internal state changes.

Observer Pattern

A design pattern that separates the display of an object from the object itself, allowing multiple displays associated with the object.

Refactoring

Changing a program to reduce its complexity without changing the external behavior of that program.

Code Smell

Indicators in the code that there might be a deeper problem.

Input Validation

Checking that a user’s input is in the correct format and that its value is within the range defined by input rules.

Type Coercion

Using functions such as int() in Python to convert the input string into the desired type.

Regular Expressions (REs)

A way of defining patterns for searching and validating text.

Exception Handling

A mechanism in programming languages to handle events that disrupt the normal flow of processing in a program.

Activity Logging

Keeping a log of what the user has done and providing a way to replay that against their data.

Auto-Save

Automatically saving the user’s data at set intervals to prevent data loss.

Data Failures

Situations where the outputs of a computation are incorrect.

Program Exceptions

Situations where the program enters a state where normal continuation is impossible.

Timing Failures

Situations where interacting components fail to respond on time or where the responses of concurrently-executing components are not properly synchronized.

Secure Failure

Ensuring that confidential data is not left in a state where an attacker can gain access to it during a failure.

External Service Failure

Failures that occur outside of the system.

Abstraction

A way to manage complexity by hiding unnecessary implementation details.

Cohesion

The degree to which the elements inside a module belong together.

Module

A self-contained component of a larger system.

Interface

A shared boundary across which two or more separate components exchange information.

Data Alias

Two or more variables that refer to the same memory location.

Data Type

A classification identifying one of various types of data, such as integer, floating-point, character, etc.

Assertion

A statement in the code that expresses a belief about the program's state.

Anomalies

Unexpected or unusual occurrences.

Buffer overflow

An anomaly where a program writes data beyond the boundaries of an allocated buffer.

SQL injection

A code injection technique used to attack data-driven applications.

Code Injection

The exploitation of a computer bug that is caused by processing invalid data.

Pollute Database

Corrupt the integrity of the data.

Linting

The automated checking of the source code.

Code Review

A systematic examination (often peer review) of computer source code.

Unit Testing

A software testing method by which individual units of source code.

Integration Testing

The phase in software testing in which individual software modules are combined and tested as a group.

Concurrency

The ability of a program to execute multiple tasks seemingly at the same time.

Parallelism

The actual simultaneous execution of multiple tasks.

Object-Oriented Programming

A programming paradigm based on 'objects', which contain data, in the form of fields.

Abstraction

Representing essential features without including background details or explanations.

Data Structure

A particular way of organizing data in a computer so that it can be used efficiently.

Algorithm

A process or set of rules to be followed in calculations or other problem-solving operations, especially by a computer.

Database Schema

The structure of a database. It defines how the data is organized within a database.

Code Management System

A system to manage changes to computer programs, documents, large web sites, or other collections of information.

Functional Programming

A programming paradigm where programs are constructed by applying and composing functions.

Imperative Programming

A programming paradigm that uses statements that change a program's state.

Declarative Programming

A programming paradigm that expresses the logic of a computation without describing its control flow.

Side-effect

A function or expression is said to have a side effect if it modifies some state outside its scope or has an observable interaction

Code Coverage

A measurement used to describe the degree to which the source code of a program is tested.

API(Application Programming Interface)

A way for two or more computer programs to communicate with each other.

Data Invariants

Conditions that are always true at a particular point in a program.

Deadlock

A situation in which two or more computing tasks are each waiting for the other to finish.

Race condition

Occurs when two or more threads can access shared data and they try to change it at the same time.

Fuzzing

An automated software testing technique that involves providing invalid, unexpected, or random data as inputs to a program.

Regression Testing

Reteesting software after modifications, to ensure that any defects introduced during development or testing have been fixed and that no other previously working functions have failed as a result of the alterations.

Fail Secure

Design principle that dictates that if a system fails, it should fail in a way that prevents sensitive information from being exposed.

Cross-site scripting (XSS)

A type of computer security vulnerability typically found in web applications.

Directory traversal

An HTTP attack that enables attackers to access restricted directories and execute commands outside of the web server's root directory.

Remote code execution

The capability to execute arbitrary commands or code on a remote device or server.

Denial-of-service attack.

An attack meant to shut down a machine or network, making it inaccessible to its intended users.

Backdoor

A means of bypassing normal authentication, used for securing remote access to a computer system.

Compiled language

A programming language whose implementations are typically compilers.

Interpreted language

A type of programming language for which most of its implementations execute instructions directly, without previously compiling a program into machine-language instructions.

Syntax

The set of rules that define the combinations of symbols that are considered to be correctly structured programs in that language.

Semantics

The field concerned with the rigorous mathematical study of the meaning of programming languages.

Robustness

The ability of a computer system to cope with errors during execution and cope with erroneous input.

Error Handling

The process of responding to and recovering from error conditions in a software application.

Code Debt

The implied cost of rework caused by choosing an easy solution now instead of using a better approach that would take longer.

Technical Debt

The implied cost of rework caused by choosing an easy solution instead of taking a better approach which would take longer.

Idempotent

An operation that can be applied multiple times without changing the result beyond the initial application.

Threadsafe

Computer code that can be safely executed by multiple concurrent threads without causing unintended data corruption or other race conditions.

Data race

Occurs when multiple threads access the same memory location concurrently, and at least one of the threads is writing to the memory location, and the threads are not using any synchronization mechanisms.

API versioning

The process of managing changes to an application programming interface while ensuring that it remains compatible with existing clients.