Programming Languages Concepts Quiz

A set of rules that determine how the value of a variable is accessed based on the location where it is referenced in the program.

A scope type where references to a variable are resolved based on the order in which functions are called, meaning the most recently called function's variables are visible.

A scope type where references to a variable are resolved based on the physical placement of the code, meaning variables declared in enclosing blocks or functions are always visible within their scope.

The duration of an entity's existence in memory.

A collection of all names visible to a statement.

Variables that are bound to a value only once when they are initialized. They cannot be modified after their value is assigned.

Constants whose values are established during compilation.

Constants whose values can be changed during execution.

In static scoping, the scope of variables is determined by the textual structure of the program, making it easier to determine the accessibility of variables at compile time. However, this can lead to a reliance on global variables, potentially impacting maintainability and modularity.

A potential issue with static scoping. When a program needs to access data belonging to a procedure lower in the call chain, there is no easy way to do so without breaking the structure of static scoping. This can lead to either moving the data to a higher level in the call chain, potentially making it accessible to unintended procedures, or moving the code causing the issue, which may create other problems.

In dynamic scoping, the scope of variables is determined by the current sequence of procedure calls, making it a flexible approach. However, it introduces the challenge of predicting the scope of variables at compile time, potentially increasing the complexity of program analysis and maintenance.

The rules that determine the order in which operators are evaluated when they are mixed together in an expression. For example, multiplication and division usually have higher precedence than addition and subtraction.

The rules that determine how operators of the same precedence are grouped. Usually, operators are grouped from left to right. For example, in a / b * c, division is performed first because it's on the left.

The process of evaluating the operands of an expression. The order in which operands are evaluated can sometimes have an impact on the final result, especially if they have side effects.

A situation where evaluating an operand has an effect on the program's state beyond the expression, like changing a variable's value. This can have unintended consequences if the order of evaluation is not clear.

The ability of an operator to perform different operations depending on the operand types it's used with. For example, + can perform addition on numbers, concatenation on strings, and other operations depending on the context.

In expressions, mixing different data types (e.g., integer and float) can lead to the compiler or interpreter converting one type to another. The conversion rules determine the type of the final result.

An expression that combines operators, operands, parentheses, and function calls to represent a computation. Example: 3 + 5 * 2

The core of imperative programming languages. They assign the value of an expression to a variable. Examples: a = 5, total += score

A mechanism in programming languages that allows for handling unexpected events during program execution, gracefully handling errors and preventing program crashes.

A block of code that is executed when a specific type of exception is thrown during program execution.

The process of signaling an error or unexpected event to the program's runtime environment.

A clause in the exception handling mechanism that specifies the types of exceptions that a particular handler can handle.

An exception that is not handled by any exception handler in the current function or its calling chain.

The ability to continue program execution after an exception has been handled, potentially resuming normal operation after the error has been addressed.

A mechanism in exception handling that allows a function to specify the types of exceptions it may raise during execution.

A mechanism in exception handling that allows a function to raise any type of exception, regardless of whether it is specified.

It determines the order in which operators with the same precedence level are evaluated in an expression. For example, most languages evaluate operators from left to right, while the exponentiation (**) operator typically evaluates from right to left.

A conditional expression allows you to choose between two values based on the result of a condition. It's a compact way of writing an if-else statement in a single line. In C-based languages, it's typically in the form: condition ? true_value : false_value If the condition is true, the expression evaluates to the true_value; if it's false, it evaluates to the false_value.

It's the order in which the values of the operands in an expression are determined. This process involves fetching values from memory for variables, using constants that may or may not need memory access, and evaluating parenthesized expressions before other operations.

A functional side effect happens when a function modifies a variable outside its own scope, like a two-way parameter or a non-local variable. This can lead to unexpected results, as the value of a variable used in an expression might be changed by a function called within that same expression.

Disallowing two-way parameters and non-local references in functions can prevent functional side effects. It's strictly enforced and ensures predictable behavior, but it can limit flexibility. Another approach is to fix operand evaluation order, which is less flexible but also prevents side effects.

The order in which operands are evaluated can impact the final outcome of an expression, especially in the presence of functions with side effects. For example, if a function modifies a variable used in the same expression, the result may be different depending on when the function is called during the evaluation.

An exception that is not checked by the compiler. The program can continue to run even if an unchecked exception occurs, but it might still lead to unexpected behavior or errors.

An exception that is checked by the compiler. The program will not compile unless the exception is handled or declared in the throws clause of the method.

A code block that is executed regardless of whether an exception is thrown or not in the try block.

A block of code that attempts to execute potentially problematic code. If an exception is thrown within the try block, it can be caught and handled.

A block of code that catches specific exceptions and handles them appropriately. It is placed after the try block.

When a method throws an exception, it may be handled by a catch block within the method itself. If not, it will be propagated up the call stack until it is caught or reaches the top level. If it reaches the top level, the program will terminate.

An event that interrupts the normal flow of program execution. It can be caused by various issues like invalid input, file not found, or network errors.