Scripting-and-Programming-Foundations Questions and Answers

Comprehensive and Detailed Explanation From Exact Extract:

C and Java are both compiled languages, though they differ in their compilation process. According to foundational programming principles, C is compiled directly to machine code, while Java is compiled to bytecode, which is executed by the Java Virtual Machine (JVM).

Option A: "Machine code." This is incorrect. Machine code is the low-level output of a compiler, not a programming language. C and Java are high-level languages.

Option B: "Compiled." This is correct. C is compiled to machine code (e.g., .exe files), and Java is compiled to bytecode (.class files), which is then executed by the JVM. Both require a compilation step before execution.

Option C: "Interpreted." This is incorrect. Neither C nor Java is interpreted. While Java’s bytecode is executed by the JVM, the compilation to bytecode distinguishes it from interpreted languages like Python, which execute source code directly.

Option D: "Markup." This is incorrect. Markup languages (e.g., HTML) are used for structuring content, not programming. C and Java are programming languages.

Certiport Scripting and Programming Foundations Study Guide (Section on Compiled Languages).

Java Documentation: “The Java Compiler” (https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javac.html).

W3Schools: “C Introduction” (https://www.w3schools.com/c/c_intro.php).

Comprehensive and Detailed Explanation From Exact Extract:

A sorting algorithm is correct if it consistently produces a sorted output (e.g., ascending order: [6, 8, 10] for input [10, 6, 8]). According to foundational programming principles, if an algorithm fails to sort any input correctly, it is considered incorrect for the general case.

Analysis:

Input: [10, 6, 8].

Output: [6, 10, 8].

Correct sorted output: [6, 8, 10] (ascending).

The algorithm’s output [6, 10, 8] is not sorted, as 10 > 8.

Option A: "The algorithm is incorrect." This is correct. Since the algorithm fails to sort [10, 6, 8] correctly, it is not a valid sorting algorithm for arbitrary inputs. A single failure proves incorrectness for the general case.

Option B: "The algorithm only works for [10, 6, 8]." This is incorrect. The algorithm does not “work” for [10, 6, 8], as it produces an incorrect output.

Option C: "The algorithm’s correctness is unknown." This is incorrect. The given example demonstrates incorrectness, so the algorithm is known to be incorrect.

Option D: "The algorithm is correct." This is incorrect. The algorithm fails to sort the given input correctly.

Certiport Scripting and Programming Foundations Study Guide (Section on Sorting Algorithms).

Cormen, T.H., et al., Introduction to Algorithms, 3rd Edition (Chapter 2: Sorting).

GeeksforGeeks: “Sorting Algorithms” (https://www.geeksforgeeks.org/sorting-algorithms/).

Comprehensive and Detailed Explanation From Exact Extract:

A loop variable update statement changes the value of the loop variable to progress the loop toward termination. In a while loop, this typically occurs within the loop body. According to foundational programming principles, the update statement modifies the loop control variable (here, h).

Code Analysis:

integer h = 7: Initializes h (not an update).

while h < 30: Loop condition (not an update).

Put h to output: Outputs h (not an update).

h = h + 2: Updates h by adding 2, progressing the loop.

Option A: "h < 30." Incorrect. This is the loop condition, not an update.

Option B: "h = h + 2." Correct. This statement updates the loop variable h, incrementing it by 2 each iteration.

Option C: "Put h to output." Incorrect. This is an output statement, not an update.

Option D: "integer h = 7." Incorrect. This is the initialization, not an update.

Certiport Scripting and Programming Foundations Study Guide (Section on Loops and Variables).

Python Documentation: “While Statements” (https://docs.python.org/3/reference/compound_stmts.html#while).

W3Schools: “C While Loop” (https://www.w3schools.com/c/c_while_loop.php).

Measure and mark the lumber cuts: This step involves measuring and marking the specific cuts required for the picnic table. It ensures that the lumber pieces are appropriately sized for assembly.

Determine the needed materials: Before purchasing materials, it’s essential to determine what is required. This step involves creating a list of necessary items such as lumber, screws, paint, etc.

Buy the needed materials: Once the materials list is ready, proceed to purchase them. This step ensures that you have all the necessary supplies before starting the construction.

Cut the lumber to the proper dimensions: With the materials on hand, cut the lumber according to the measurements marked in step 1. This ensures that the pieces fit together correctly during assembly.

Assemble the pieces and paint: Finally, assemble the cut lumber pieces to create the picnic table. After assembly, apply paint or finish as desired.

References

No specific references are provided for this question, but the steps align with general woodworking practices for constructing a picnic table. You can refer to woodworking guides or carpentry resources for further details.

Comprehensive and Detailed Explanation From Exact Extract:

A while loop repeatedly executes a block of code as long as a condition is true, making it suitable for tasks requiring iteration until a condition changes. According to foundational programming principles, while loops are ideal for scenarios with an unknown number of iterations or conditional repetition.

Option A: "When the user inputs a number, the program outputs 'True' when the number is a multiple of 10." This is incorrect. This task requires a single check (number % 10 == 0), which can be done with an if statement, not a loop.

Option B: "The user inputs an integer, and the program prints out whether the number is even or odd and whether the number is positive, negative, or zero." This is incorrect. This task involves a single input and multiple conditional checks, handled by if statements, not a loop.

Option C: "After inputting two numbers, the program prints out the larger of the two." This is incorrect. Comparing two numbers requires a single if statement (e.g., if (a > b)), not a loop.

Option D: "A user is asked to enter a password repeatedly until either a correct password is entered or five attempts have been made." This is correct. This task requires repeated input until a condition is met (correct password or five attempts), which is ideal for a while loop. For example, in Python:

attempts = 0

while attempts < 5 and input("Password: ") != "correct":

attempts += 1

Certiport Scripting and Programming Foundations Study Guide (Section on Control Structures: Loops).

Python Documentation: “While Statements” (https://docs.python.org/3/reference/compound_stmts.html#while).

W3Schools: “C While Loop” (https://www.w3schools.com/c/c_while_loop.php).

Here's the typical flow of the Waterfall software development model:

Analysis: This phase focuses on defining the problem and gathering detailed requirements for the software. Understanding the specific mathematical operations to support is a key part of this phase.

Design: Designers turn the requirements from the analysis phase into a concrete blueprint for the software. This includes architectural and detailed design decisions covering how those mathematical operations will be implemented.

Implementation: Developers take the design and translate it into working code, writing the modules and functions to perform the calculations.

Testing: Testers verify the software to ensure it meets the requirements, including testing how the implemented calculator functions handle different operations.

Maintenance: Ongoing support after deployment to address bugs and introduce potential changes or enhancements.

Why the other options are less accurate:

A. Design and Testing: While testing validates the calculator's functions, the determination of the required operations happens earlier in the process.

B. Implementation and Testing: Implementation builds the calculator, but the specifications and choice of operations happen before coding starts.

C. Design and Implementation: Though closely linked, the design phase finalizes the operation choices before implementation begins.

A function definition is the blueprint for a block of code designed to perform a specific task. Here's what it includes:

Function Name: A unique name to identify and call the function (e.g., calculate_area).

Inputs (Parameters/Arguments): Values or variables passed into the function when it's called (e.g., width, height).

Outputs (Return Value): The result the function produces after processing (e.g., the calculated area). This value may or may not be explicitly returned.

Statements (Function Body): Contains the code that performs the actions and calculations within the function.

Comprehensive and Detailed Explanation From Exact Extract:

The tasks described involve creating a technical plan (listing objects and functions) and coding (writing the objects). According to foundational programming principles and Agile methodologies, these correspond to the design phase (planning the structure) and the implementation phase (coding).

Agile Phases Analysis:

Analysis: Defines requirements (e.g., “the game must support players and moves”).

Design: Specifies technical components (e.g., objects like Player, Board, and functions like makeMove()).

Implementation: Writes the code for the specified components.

Testing: Verifies the code works as intended.

Tasks Breakdown:

Creating a list of objects and functions: This is a design task, as it involves planning the program’s structure (e.g., class diagrams or function signatures).

Writing the code for each object: This is an implementation task, as it involves coding the objects (e.g., implementing the Player class).

Option A: "Analysis and design." This is incorrect. Analysis defines high-level requirements, not the specific objects and functions, which are part of design.

Option B: "Design and implementation." This is correct. Designing the list of objects and functions occurs in the design phase, and writing their code occurs in the implementation phase.

Option C: "Analysis and implementation." This is incorrect. Analysis does not involve listing technical components like objects and functions.

Option D: "Design and testing." This is incorrect. Testing verifies the coded objects, not the act of creating their list or writing their code.

Certiport Scripting and Programming Foundations Study Guide (Section on Agile Phases).

Sommerville, I., Software Engineering, 10th Edition (Chapter 4: Agile Software Development).

Agile Alliance: “Design and Implementation” (https://www.agilealliance.org/glossary/design/).

Comprehensive and Detailed Explanation From Exact Extract:

The term “based on a series of cells” is commonly associated with markup languages, particularly in the context of web development, where content is structured in a hierarchical or cell-based layout (e.g., HTML tables or CSS grid systems). According to foundational programming principles, markup languages like HTML are characterized by their use of tags to define elements, which can be visualized as cells or containers for content.

Option A: "Functional." This is incorrect. Functional languages (e.g., Haskell, Lisp) focus on functions as first-class citizens and immutability, not on a cell-based structure.

Option B: "Static." This is incorrect. “Static” refers to typing (where types are fixed at compile time) or analysis, not a cell-based structure.

Option C: "Markup." This is correct. Markup languages like HTML use tags to create elements that can be arranged in a cell-like structure (e.g., <title> or

elements in a grid). In web design, tables and CSS layouts are often described as cell-based.

Option D: "Compiled." This is incorrect. Compiled languages (e.g., C, Java) are translated into machine code before execution, but they are not characterized by a cell-based structure.

Certiport Scripting and Programming Foundations Study Guide (Section on Markup Languages).

W3Schools: “HTML Tables” (https://www.w3schools.com/html/html_tables.asp).

Mozilla Developer Network: “CSS Grid Layout” (https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout).

In the Waterfall model, a traditional software development lifecycle (SDLC) methodology, the design phase follows the requirements phase. During the design phase, the focus is on creating a detailed specification of the system to be developed. This includes:

Architectural Design: Outlining the overall structure of the system.

Interface Design: Defining how the software components will interact with each other and with users.

Component Level Design: Specifying the behavior of individual components.

Data Structure Design: Establishing how data is organized within the system.

The deliverable produced during this phase is a comprehensive design document that describes the architecture, components, interfaces, and data structures of the application in detail. It serves as a blueprint for the next phase of the Waterfall process, which is implementation (coding).

Programming libraries are collections of pre-written code that programmers can use to perform common tasks without having to write the code from scratch. They are particularly helpful in situations where:

The tasks are common and standardized across the industry, such as animation tasks in video games (Option C). Using a library can save time and resources, and also ensure that the animations are up to industry standards.

The tasks are well-known and frequently performed by many programmers, such as file compression (Option D). Libraries provide a reliable and tested set of functions that can handle these tasks efficiently.

For the other options:

A: While a library could be used, writing interacting objects and implementing inheritance is a fundamental part of object-oriented programming and may not necessarily require a library.

B: Iterating through a list to find the maximum value is a basic programming task that typically doesn’t require a library.

E: Dynamic typing or the use of variables without an initial declaration type is a feature of the programming language itself rather than a library.

F: Recursive functions are a programming concept that can be implemented without the need for a library, unless the recursion is part of a specific algorithm that a library might provide.

 The operator that is helpful in determining if an integer is a multiple of another integer is the modulus operator, represented by / in some programming languages and % in others. This operator returns the remainder of the division of one number by another. If the remainder is zero, it indicates that the first number is a multiple of the second. For example, 6 % 3 would return 0, confirming that 6 is a multiple of 3.

Start with the input value (in this case, 7).

Follow the flowchart’s paths and apply the operations as indicated by the symbols and connectors.

The rectangles represent processes or actions to be taken.

The diamonds represent decision points where you will need to answer yes or no and follow the corresponding path.

The parallelograms represent inputs/outputs within the flowchart.

Use the input value and apply the operations as you move through the flowchart from start to finish.

Comprehensive and Detailed Explanation From Exact Extract:

The algorithm counts how many times d can be subtracted from i until i is less than d, effectively computing the integer division i / d. According to foundational programming principles, we trace the loop execution.

Initial State:

i = 61, d = 6, c = 0.

Loop Execution:

While i >= d (i.e., 61 >= 6):

c = c + 1 (increment counter).

i = i - d (subtract d from i).

Iterations:

1: i = 61, c = 0 + 1 = 1, i = 61 - 6 = 55.

2: i = 55, c = 1 + 1 = 2, i = 55 - 6 = 49.

3: i = 49, c = 2 + 1 = 3, i = 49 - 6 = 43.

4: i = 43, c = 3 + 1 = 4, i = 43 - 6 = 37.

5: i = 37, c = 4 + 1 = 5, i = 37 - 6 = 31.

6: i = 31, c = 5 + 1 = 6, i = 31 - 6 = 25.

7: i = 25, c = 6 + 1 = 7, i = 25 - 6 = 19.

8: i = 19, c = 7 + 1 = 8, i = 19 - 6 = 13.

9: i = 13, c = 8 + 1 = 9, i = 13 - 6 = 7.

10: i = 7, c = 9 + 1 = 10, i = 7 - 6 = 1.

Stop: i = 1 < 6, exit loop.

Output: Put c to output outputs c = 10.

Verification: 61 ÷ 6 = 10 (integer division), with remainder 1 (since 61 - 6 * 10 = 1).

Option A: "1." Incorrect. This would occur after one iteration.

Option B: "5." Incorrect. This is too low; c reaches 10.

Option C: "10." Correct. Matches the count of subtractions.

Option D: "60." Incorrect. This is unrelated to the algorithm’s logic.

Certiport Scripting and Programming Foundations Study Guide (Section on Loops and Counters).

Python Documentation: “While Loops” (https://docs.python.org/3/reference/compound_stmts.html#while).

W3Schools: “C While Loop” (https://www.w3schools.com/c/c_while_loop.php).

E. The programmer can improve productivity by using libraries.

Why: Libraries offer pre-written, tested code for common tasks. This saves developers time and effort, leading to increased productivity.

F. Using a library prevents a programmer from having to code common tasks by hand.

Why: The core purpose of libraries is to provide reusable code solutions. This eliminates the need to reinvent the wheel for frequently used functions and operations.

C++ is a programming language that provides extensive support for object-oriented programming (OOP). OOP is a programming paradigm based on the concept of “objects”, which can contain data in the form of fields, often known as attributes, and code, in the form of procedures, often known as methods. C++ offers features such as classes, inheritance, polymorphism, encapsulation, and abstraction which are fundamental to OOP. This makes C++ a powerful tool for developing complex software systems that require a modular and scalable approach.

The information provided is based on standard programming principles and the foundational knowledge of scripting and programming, which includes understanding the capabilities and applications of various programming languages1.

The language described in the question exhibits characteristics of an interpreted, object-oriented, and dynamic language. Here’s why these terms apply:

Interpreted: The program can run on various operating systems without re-compilation, which is a trait of interpreted languages. Interpreted languages are executed line by line by an interpreter at runtime, rather than being compiled into machine code beforehand123.

Object-oriented: The use of concepts like information hiding, data abstraction, encapsulation, polymorphism, and inheritance are hallmarks of object-oriented programming (OOP). OOP languages are designed around objects and classes, which allow for modular, reusable, and organized code456.

Dynamic: Variables in the program do not need to have their types declared ahead of time, indicating dynamic typing. In dynamically typed languages, type checking is performed at runtime, and variables can be assigned to different types of data over their lifetime7891011.

A programming library is a collection of pre-written code that developers can use to optimize tasks and improve productivity. Here’s why the selected statements are correct:

A: Libraries must be included or imported into your program before you can use the functions or objects they contain. This is because the program needs to know where to find the code it’s executing12.

B: A library typically includes multiple functions, objects, or classes that are related to a specific task or area of functionality. This allows developers to reuse code efficiently12.

D: By providing pre-written code, libraries save developers time and effort, which in turn improves their productivity. Instead of writing code from scratch, developers can focus on the unique aspects of their project12.

The other options are incorrect because:

C: While it’s true that poorly designed libraries can affect performance, well-designed libraries can actually make programs more efficient by providing optimized code.

E: A single program can include multiple libraries as needed. There’s no limit to the number of libraries a program can use.

F: Libraries often contain multiple functions and variables, not just one function.

The code snippet not (g != S) contains two types of operators:

Equality Operator (!=): The expression g != S checks whether the value of g is not equal to the value of S. The != operator is used for comparison and returns True if the values are different, otherwise False.

Logical Operator (not): The not operator is a logical negation operator. It inverts the truth value of a Boolean expression. In this case, not (g != S) evaluates to True if g is equal to S, and False otherwise.

Therefore, the combination of these two operators results in the overall expression not (g != S).

Programming libraries offer a collection of pre-written code that developers can use to perform common tasks, which saves time and effort. This is because:

B. Libraries provide pre-coded functions and procedures, which means programmers don’t need to write code from scratch for tasks that are common across many programs. This reuse of code enhances efficiency and reduces the potential for errors in coding those tasks.

E. By using libraries, programmers can significantly improve their productivity. Since they are not spending time writing and testing code for tasks that the library already provides, they can focus on the unique aspects of their own projects.

The pseudocode provided appears to be a loop that calculates the sum of numbers. Without seeing the exact pseudocode, I can deduce based on common programming patterns that if the loop is designed to add numbers from 1 to 5, the sum would be 1 + 2 + 3 + 4 + 5, which equals 15. This is a typical example of a series where the sum of the first n natural numbers is given by the formula

2n(n+1)​

, and in this case, with n being 5, the sum is

25(5+1)​=15

In programming, a function that calculates the average of two numbers will require both numbers as input to perform the calculation. These inputs are known as parameters. Once the function has completed its calculation, it should return the result. In this case, the result is the average of the two numbers, which is the return value.

Here’s a simple example in pseudocode:

function calculateAverage(x, y) {

average = (x + y) / 2

return average

}

In this function, x and y are the parameters, and the average is the calculated value that the function returns after execution.

Comprehensive and Detailed Explanation From Exact Extract:

Dijkstra’s shortest path algorithm finds the shortest path between nodes in a weighted graph, often used for navigation or network routing. According to foundational programming principles (e.g., Certiport Scripting and Programming Foundations Study Guide, Section on Algorithms), it is designed for problems involving optimal paths in graphs with non-negative edge weights.

Option A: "Given an increasing array of numbers, is the number 19 in the array?" This is incorrect. This is a search problem, typically solved by binary search for a sorted array, not Dijkstra’s algorithm, which deals with graphs.

Option B: "Given an alphabetized list of race entrants and a person’s name, is the person entered in the race?" This is incorrect. This is another search problem, solvable by binary search or linear search, not related to graph paths.

Option C: "Given two newspaper articles, what is the greatest sequence of words shared by both articles?" This is incorrect. This is a longest common subsequence (LCS) problem, solved by dynamic programming, not Dijkstra’s algorithm.

Option D: "Given the coordinates of five positions, what is the most fuel-efficient flight path?" This is correct. This describes a shortest path problem in a graph where nodes are positions (coordinates) and edges are distances or fuel costs. Dijkstra’s algorithm can find the most efficient path (e.g., minimizing fuel) between these points, assuming non-negative weights.

Certiport Scripting and Programming Foundations Study Guide (Section on Algorithms).

Cormen, T.H., et al., Introduction to Algorithms, 3rd Edition (Dijkstra’s Algorithm, Chapter 24).

GeeksforGeeks: “Dijkstra’s Shortest Path Algorithm” (https://www.geeksforgeeks.org/dijkstras-shortest-path-algorithm-greedy-algo-7/).

Interpreted languages are designed to be executed one statement at a time by an interpreter. This allows for immediate execution and feedback, which is useful for debugging and interactive use. Unlike compiled languages, interpreted languages do not generate machine code prior to execution, and they do not produce syntax errors during compilation because there is no compilation step. They are not restricted to one machine, as the interpreter can be implemented on various systems, and they do not require the programmer to write machine code.

Comprehensive and Detailed Explanation From Exact Extract:

A compiled programming language is one where the source code is translated into machine code (or an intermediate form) by a compiler before execution. According to foundational programming principles (e.g., Certiport Scripting and Programming Foundations Study Guide), this process results in an executable file that can run independently of the compiler.

Option A: "The program usually runs slower than an interpreted language." This is incorrect. Compiled languages (e.g., C, C++) typically produce machine code that runs faster than interpreted languages (e.g., Python), as the translation to machine code is done beforehand, avoiding runtime interpretation overhead.

Option B: "The code runs directly one statement at a time by another program called a compiler." This is incorrect. A compiler translates the entire program into machine code before execution, not one statement at a time. Running code one statement at a time is characteristic of an interpreter, not a compiler.

Option C: "The code must be compiled into machine code in the form of an executable file before execution." This is correct. In compiled languages like C or Java (which compiles to bytecode), the source code is translated into machine code or an intermediate form (e.g., .exe or .class files) that can be executed directly by the machine or a virtual machine.

Option D: "The code does not require being translated into machine code but can be run by a separate program called a compiler." This is incorrect. A compiler’s role is to translate code into machine code. Running code without translation describes an interpreted language, and the term “compiler” is misused here.

Certiport Scripting and Programming Foundations Study Guide (Section on Compiled vs. Interpreted Languages).

C Programming Language Standard (ISO/IEC 9899:2011).

W3Schools: “C Introduction” (https://www.w3schools.com/c/c_intro.php).

 The correctness of a sorting algorithm is determined by its ability to sort a list of elements into a specified order, typically non-decreasing or non-increasing order. For an algorithm to be considered correct, it must consistently produce the correct output for all possible inputs. In the case of the given algorithm, it takes the input list [10, 8] and produces the output [6, 10, 8], which is not sorted in non-decreasing order. This indicates that the algorithm does not correctly sort the list, as the output is neither sorted nor does it maintain the integrity of the original list (the number 6 was not in the original list).

Furthermore, the fact that the output contains an integer (6) that was not present in the input list suggests that the algorithm is not preserving the elements of the input list, which is a fundamental requirement for a sorting algorithm. This violation confirms that the algorithm is incorrect for sorting an arbitrary list of three integers, as it cannot be relied upon to sort correctly or maintain the original list elements.

In programming, a loop variable update statement is used to modify the loop variable’s value with each iteration of the loop. This is crucial for the progression and eventual termination of the loop. The statement h = h + 1 is a classic example of a loop variable update statement. It increments the value of h by 1, ensuring that the loop can move towards its completion condition. Without such an update, the loop could potentially continue indefinitely, leading to an infinite loop.

The algorithm is designed to output “OK” if the input number is within the range of 98.3 to 98.9. Therefore, the valid test would be one that checks if the algorithm correctly identifies a number within this range and outputs “OK”. Option B provides an input of 98.6, which falls within the specified range, and expects the correct output of “OK”, making it a valid test case for the algorithm.

The C(M) programming language is designed to translate mathematical constructions into efficient C programs. It is a declarative functional language with strong type checking and supports high-level functional programming. The C(M) compiler translates the C(M) program into a readable C program, which then needs to be compiled into machine code in the form of an executable file before it can be executed1. This process is typical of compiled languages, where the source code is transformed into machine code, which can be directly executed by the computer’s CPU. In contrast, interpreted languages are typically run by an interpreter, executing one statement at a time, which generally results in slower execution compared to compiled languages.

 When dealing with body temperature, especially in Fahrenheit, the appropriate data type to use is a floating-point number (float). Here’s why:

Measurement Precision:

Body temperature can have decimal values, such as 98.6°F.

Integer data types (like B. Integer) cannot represent fractional values.

Floats allow for greater precision and can handle decimal places.

Temperature Scales:

Fahrenheit is a continuous scale, not a discrete set of values.

It includes both positive and negative values (e.g., sub-zero temperatures).

Floats accommodate this range effectively.

Examples:

A person’s body temperature might be 98.6°F (normal) or 101.3°F (fever).

These values require a data type that can handle fractions.

 In programming, a string is used to store sequences of characters, which can include letters, numbers, symbols, and spaces. Strings are typically utilized to store textual data, such as words and sentences12. For example, the word “positive” would be stored as a string. While strings can contain numbers, they are not used to store numbers in their numeric form but rather as text. Therefore, options A, C, and D, which involve numbers or boolean values, would not be stored as strings unless they are meant to be treated as text.

A compiled language is one where the source code is translated into machine code, which is a set of instructions that the computer’s processor can execute directly. This translation is done by a program called a compiler. Once the source code is compiled into an executable file, it can be run on the target machine without the need for the original source code or the compiler. This process differs from interpreted languages, where the code is executed one statement at a time by another program called an interpreter, and there is no intermediate executable file created.

Option A describes an interpreted language, not a compiled one. Option B refers to type safety, which is a feature of some programming languages but is not specific to compiled languages. Option C describes a script or an interpreted language, which can be executed immediately by an interpreter without compilation.

Comprehensive and Detailed Explanation From Exact Extract:

An interpreted language is executed directly by an interpreter, which reads and executes the source code line by line without requiring a separate compilation step. According to foundational programming principles, this allows for flexibility, such as running code interactively or one statement at a time.

Option A: "Generates syntax errors during compilation." This is incorrect. Interpreted languages (e.g., Python, JavaScript) do not undergo a compilation phase. Syntax errors are detected during execution by the interpreter, not during a compilation step.

Option B: "Can be run by a user one statement at a time." This is correct. Interpreted languages often support interactive execution, where users can input and execute code one statement at a time (e.g., in Python’s REPL or JavaScript’s browser console). This is a hallmark of interpreters.

Option C: "Has a programmer writing machine code." This is incorrect. No high-level programming language, interpreted or compiled, requires programmers to write machine code. Interpreted languages use high-level source code executed by an interpreter.

Option D: "Is restricted to running on one machine." This is incorrect. Interpreted languages are typically portable across machines, as long as the interpreter is available (e.g., Python runs on Windows, macOS, and Linux with the same source code).

Certiport Scripting and Programming Foundations Study Guide (Section on Interpreted Languages).

Python Documentation: “Interactive Mode” (https://docs.python.org/3/tutorial/interpreter.html).

W3Schools: “JavaScript Introduction” (https://www.w3schools.com/js/js_intro.asp).

Comprehensive and Detailed Explanation From Exact Extract:

The expression x - y * 2 involves subtraction and multiplication, evaluated according to operator precedence. According to foundational programming principles (e.g., C and Python standards), multiplication (*) has higher precedence than subtraction (-), so y * 2 is computed first.

Given: x = 12, y = 4.

Compute: y * 2 = 4 * 2 = 8.

Then: x - (y * 2) = 12 - 8 = 4.

Option A: "4." This is correct, as calculated above.

Option B: "6." This is incorrect. It might result from misinterpreting precedence (e.g., (x - y) * 2 = (12 - 4) * 2 = 16).

Option C: "8." This is incorrect. It might result from computing x - y = 12 - 4 = 8 and ignoring * 2.

Option D: "14." This is incorrect. It does not align with the expression’s evaluation.

Certiport Scripting and Programming Foundations Study Guide (Section on Operator Precedence).

C Programming Language Standard (ISO/IEC 9899:2011, Section on Expressions).

W3Schools: “Python Operators” (https://www.w3schools.com/python/python_operators.asp).

One of the fundamental characteristics of object-oriented programming (OOP) is the concept of decomposing a program into objects that interact with one another1. This is distinct from procedural and functional programming paradigms, which do not inherently structure programs as a collection of objects. In OOP, objects are instances of classes and contain both data (attributes) and code (methods). These objects encapsulate data and operations and can interact with each other through methods, allowing for concepts such as inheritance, polymorphism, and encapsulation12.

In contrast, procedural programming is characterized by a focus on procedures or routines to perform tasks, and functional programming treats computation as the evaluation of mathematical functions without side effects or state changes2. Neither paradigm organizes code around objects with encapsulated data and methods, which is a defining feature of OOP1.

Comprehensive and Detailed Explanation From Exact Extract:

Equality operators compare two values to determine if they are equal or not equal, returning a boolean result. According to foundational programming principles, common equality operators are == (equal to) and != (not equal to).

Option A: "-." This is incorrect. The subtraction operator (-) is an arithmetic operator, not an equality operator.

Option B: "==." This is correct. The equality operator (==) checks if two values are equal (e.g., 5 == 5 returns True).

Option C: "/." This is incorrect. The division operator (/) is an arithmetic operator, not an equality operator.

Option D: "not." This is incorrect. The not operator is a logical operator that negates a boolean value, not an equality operator.

Option E: "<=." This is incorrect. The less-than-or-equal-to operator (<=) is a relational (comparison) operator, not an equality operator.

Option F: "!=." This is correct. The not-equal-to operator (!=) checks if two values are not equal (e.g., 5 != 3 returns True).

Certiport Scripting and Programming Foundations Study Guide (Section on Operators).

C Programming Language Standard (ISO/IEC 9899:2011, Section on Equality Operators).

W3Schools: “Python Operators” (https://www.w3schools.com/python/python_operators.asp).