Fundamentals of Computation Quiz

Abstraction: Representing complex systems in simplified ways to understand and manage. This simplifies complexity for easier comprehension.
Algorithms: Step-by-step procedures for solving problems. They define the logic and steps to get from an input to an output.
Data structures: Organized ways of storing data to facilitate efficient access and manipulation. Examples include arrays, linked lists, stacks, queues, trees, and graphs – each with strengths for particular tasks.
Programming paradigms: Different approaches to structuring programs. Examples include procedural, object-oriented, and functional programming. Each method offers distinct ways to think about and structure code.

Variables: Named storage locations that hold data values. Variables are essential to store and manipulate data during program execution.
Data types: Categories of data. Examples include integers, floating-point numbers, strings, booleans. Choosing appropriate data types ensures efficient memory usage and correct operations.
Operators: Symbols that perform operations on data. Examples include arithmetic (+, -, *, /), relational (==, !=, >, <), and logical operators (AND, OR, NOT). These allow for calculations and comparisons in code.
Control flow: Statements that determine the order of execution in a program. Examples include conditional statements (if-else) and iterative statements (loops). These control the path the program takes, selecting actions based on conditions or repeating blocks of code.
Functions: Blocks of reusable code that perform a specific task. Functions break down large tasks into smaller, manageable units, promoting code organization and re-use.

Arrays: Ordered collections of data stored in contiguous memory locations. Arrays offer fast access to elements by index but are less flexible for dynamic changes in size.
Linked lists: Data elements connected sequentially by pointers or references. They are suited to dynamic sizes. Nodes contain data and a reference to the next node.
Stacks: A Last-In, First-Out (LIFO) data structure useful for managing temporary data or for function calls. Think of a stack of plates – you take the top one off.
Queues: A First-In, First-Out (FIFO) data structure like a queue of people waiting. Processing is done in the order of arrival.
Trees: Hierarchical data structure with a root node and branches formed by child nodes. Binary trees limit each node to a maximum of two children.
Graphs: A collection of nodes (vertices) connected by edges. Graphs are useful for modeling relationships and networks.
Searching and sorting algorithms: Techniques to find specific data elements (e.g., linear, binary search) and arrange data in a particular order (e.g., bubble sort, merge sort, quicksort). Choosing the right algorithm is crucial for efficiency based on data size and characteristics.

Central Processing Unit (CPU): The "brain" of the computer; fetches, decodes, and executes instructions.
Memory (RAM): Stores data and instructions that the CPU is currently using, providing fast access.
Input/Output (I/O) devices: Devices that allow the computer to interact with the outside world (e.g., keyboard, mouse, monitor, printer). They transfer data between the computer and the external environment.
Storage devices (e.g., hard drives, SSDs): Store data persistently when the computer is turned off. Hard drives use moving parts which are slower but SSDs use flash memory to provide significantly quicker data access.
Bus systems: Electrical pathways that allow data to travel between components in the computer. Connects different parts of the computer to transmit data efficiently.

Agile development: An iterative approach to software development focused on flexibility and responding to change. This allows teams to adapt quickly to new requirements.
Waterfall model: A sequential approach to software development where each phase must be completed before the next can begin. Although simple, it can be slow to respond to changes.
Testing: Verifying the functionality and correctness of software through various tests. Testing is a crucial part of ensuring software quality and discovering bugs early on. This includes unit tests, integration tests, and system tests.

Problem decomposition: Breaking down a complex problem into smaller, more manageable subproblems. This allows for focused solutions and organized approach.
Abstraction: Hiding unnecessary details to focus on essential aspects. This makes complex problems easier to understand and solve.
Pattern recognition: Identifying recurring patterns and trends in data or problems to solve them efficiently. This improves code efficiency and problem-solving strategies.
Automation: Employing computational tools to perform tasks automatically. Finding ways to use computers for repetitive tasks improves efficiency and reduces errors.

Bits and Bytes: The fundamental units of digital information. Understanding how these units represent data is critical to programming.
Binary representation: How computers represent information as sequences of 0s and 1s. This forms the basis for all digital data.
Computer networks: How computers communicate with each other via networks. Understanding the protocol structure and internet infrastructure is key to understanding how the internet works.
Databases: Structured collections of data. Databases are essential for storing and retrieving large amounts of data.

Data privacy: Protecting the privacy of user data is important. Data handling procedures, security methods, and policies all form part of responsible use of computer systems.
Bias in algorithms: Recognizing that algorithms can reflect and perpetuate biases in the data they are trained on. This requires careful consideration to minimize bias in results.
Accessibility: Ensuring that technology is accessible to people with disabilities. Designing systems with consideration for accessibility is essential for inclusion.
Intellectual property: Understanding the rights associated with creating and distributing software and digital material.