WGU Foundations-of-Computer-Science - WGU Foundations of Computer Science

In programming, a function takes inputs, performs computation, and may return an output. The standard term for a function’s inputs isarguments(also commonly discussed alongside the closely related termparameters). Textbooks typically distinguish the two:parametersare the names listed in the function definition, whileargumentsare the actual values supplied when the function is called. For example, in def f(x, y):, x and y are parameters. In the call f(3, 5), 3 and 5 are arguments. Many introductory materials use “arguments” informally to refer to the inputs overall, which matches the wording of this question.

Options A, B, and C do not fit the textbook definition. “Variables” is too broad; inputs can be literals, expressions, or variables, but the conceptual role is “arguments.” “Procedures” are callable units of code (often used in some languages to mean functions without return values), not the inputs. “Outputs” refers to returned results, not what you pass in.

Understanding arguments is important because it connects to call semantics, scope, and correctness. Different languages support positional arguments, keyword arguments, default values, and variadic arguments (e.g., *args, **kwargs in Python). This flexibility shapes API design and influences how programmers structure reusable code.

“Encryption in transit” means protecting data while it moves across a network so that eavesdroppers cannot read or modify it. For email systems, this protection is most commonly provided byTLS (Transport Layer Security). TLS is a cryptographic protocol that can wrap application protocols (including mail protocols) to provide confidentiality, integrity, and server (and sometimes client) authentication. In practice, TLS is used to secure connections such as SMTP submission (often with STARTTLS or implicit TLS), IMAP over TLS, and POP3 over TLS. Textbooks present TLS as the standard successor to SSL and the foundation of secure communication on the modern Internet.

The other options are not correct in this context. FTP is a file transfer protocol and is traditionally unencrypted unless paired with additional security mechanisms (e.g., FTPS, which uses TLS, or SFTP, which uses SSH). HTTP is a web protocol; it becomes encrypted only when used as HTTPS, which again relies on TLS underneath. IMAP is an email retrieval protocol, butIMAP itself is not the encryption protocol—IMAP can be run over TLS (IMAPS) to become secure.

Therefore, the protocol that provides encryption while email messages (or email protocol traffic) are in transit is TLS.

In Python, slicing is the standard mechanism for extracting arangeof elements from a sequence type such as a list, string, or tuple. The character that signals a slice range is thecolon:. The general slice syntax is sequence[start:stop:step]. Most commonly, you see sequence[start:stop], where start is the index to begin from (inclusive) and stop is the index to end at (exclusive). This “inclusive start, exclusive stop” rule is emphasized in textbooks because it makes slice lengths easy to reason about: when step is 1, the number of elements returned is stop - start.

For example, if items = ["a", "b", "c", "d", "e"], then items[1:4] returns ["b", "c", "d"]. Omitting start defaults to the beginning (items[:3] gives the first three elements), and omitting stop defaults to the end (items[2:] gives everything from index 2 onward). The optional step supports patterns like items[::2] for every other element, and negative steps can reverse a sequence (items[::-1]).

The other characters do not define ranges in Python slicing: , separates items (or indices in multidimensional structures), + is addition/concatenation, and = is assignment. The colon is the slicing operator that indicates a range.

Windows commonly uses the NTFS (New Technology File System) for internal drives and many external drives because it supports advanced features required for modern operating systems. One of the most important features is support forfile and folder permissionsvia Access Control Lists (ACLs). Permissions enable the OS to enforce security policies by controlling which users and groups can read, write, execute, modify, or delete specific resources. This is fundamental to multi-user security and is a standard topic in operating systems and security textbooks.

FAT32 is an older file system designed for simplicity and broad compatibility. It does not provide the same fine-grained permission model as NTFS, which is why it is often used for removable media where cross-platform compatibility matters more than access control. HFS+ is historically associated with Apple’s macOS systems, and EXT4 is widely used on Linux. While these file systems have their own permission and feature models, they are not the common Windows default for permission-managed storage in typical Windows deployments.

NTFS also supports journaling (improving reliability after crashes), large file sizes, quotas, compression, and encryption features (through Windows facilities). In enterprise environments, NTFS permissions integrate with Windows authentication and directory services, enabling centralized user management. Therefore, for Windows systems requiring file permissions, NTFS is the correct answer.

Python slicing uses the notation sequence[start:stop], where start is inclusive and stop is exclusive. When start is omitted, it defaults to 0, meaning the slice starts from the beginning of the sequence. Therefore, fam[:3] is equivalent to fam[0:3]. Because the stop index 3 is excluded, the slice includes elements at indices 0, 1, and 2—exactly the first three elements.

This convention is emphasized in programming textbooks because it makes many tasks natural and reduces boundary errors. For example, “take the first n items” is written as [:n], and “drop the first n items” is written as [n:]. The length of the slice is also easy to reason about: with step 1, it is stop - start, so here it is 3 - 0 = 3.

Option B is incorrect because including four elements would require fam[:4]. Option C would correspond to fam[:2]. Option D describes taking elements from the end, which would use negative indexing such as fam[-3:].

Slicing is widely used for batching, windowing in algorithms, splitting datasets into training/testing segments, and extracting prefixes in parsing tasks. Understanding the inclusive start and exclusive stop rule is essential for correct Python programming.

In Python, a list is a mutable sequence, meaning its elements can be changed after the list is created. The standard textbook method for updating a specific element isindex assignment, which uses square brackets to select the position and the equals sign to assign a new value. For example, if nums = [10, 20, 30], then nums[1] = 99 changes the element at index 1 from 20 to 99, producing [10, 99, 30]. This works because lists store references to objects and allow those references to be updated in-place.

Option B is incorrect because parentheses are used for function calls and tuples, and the plus sign typically performs concatenation (creating a new list) rather than modifying an existing element by position. Option C is incorrect because curly brackets denote dictionaries or sets, not lists. Option D is incorrect because del removes elements by index or slice (for example, del nums[1]), and it does not delete by “the element’s value” unless you first find the index. Deleting is not the same as changing; deletion reduces the list’s length and shifts later indices.

Index assignment is fundamental in list manipulation and appears in standard algorithms: updating counters, replacing sentinel values, editing collections, and implementing in-place transformations efficiently without allocating a new list.

Outlier detection often relies on measuring how far values deviate from a “typical” center. While variance and standard deviation can be used in simple z-score based methods, they arenot robust: a few extreme outliers can inflate the mean and standard deviation, masking the very outliers you want to find. A widely taught robust alternative is themedian absolute deviation (MAD), which is based on the median rather than the mean and therefore resists distortion by extreme values.

MAD is computed by first taking the median of the data, then computing the absolute deviation of each point from that median, and finally taking the median of those deviations. Because medians are stable under extreme values, MAD provides a strong baseline for identifying unusually distant points. Many textbooks and data analysis references present MAD as a robust scale estimator for outlier detection, often combined with a threshold rule such as flagging points whose deviation exceeds a constant multiple of MAD (with a scaling factor sometimes used to make it comparable to standard deviation under normality assumptions).

In NumPy, you can implement MAD using np.median() and np.abs(). Mode is generally not useful for continuous numeric outlier detection, and variance/standard deviation are more sensitive to outliers than MAD. Thus, among the given options, the best statistical measure for detecting outliers robustly is the median absolute deviation.

AnAcceptable Use Policy (AUP)defines how employees and users are permitted to use an organization’s computing resources—such as email, internet access, file storage, endpoints, and networks—and it typically specifies prohibited behaviors and the consequences of violations. In security and IT governance textbooks, the AUP is framed as both a behavioral contract and a risk-management tool: it reduces misuse, clarifies expectations, and provides an enforceable basis for disciplinary action.

The “ramifications of abusing company resources” (for example, installing unauthorized software, excessive personal use, accessing inappropriate content, attempting to bypass security controls, or sharing credentials) are precisely the kinds of issues an AUP addresses. The policy often includes monitoring statements (users have limited expectation of privacy), compliance requirements, and escalation paths for violations.

A Network Security Policy (A) focuses on technical rules for network protection—firewalls, segmentation, remote access, and intrusion detection—rather than broad user conduct and disciplinary consequences. A Physical Security Policy (B) addresses protection of facilities and hardware—badges, locks, visitor procedures, secure areas. A Data Retention Policy (D) defines how long data is stored, how it is archived, and how it is disposed, which is different from defining misuse consequences.

Thus, the policy aspect that defines permissible behavior and the consequences for abusing resources is the Acceptable Use Policy.

Python list slicing uses the notation list[start:stop], where start is inclusive and stop is exclusive. This means the slice begins at index start and includes elements up to, but not including, index stop. Lists in Python are zero-indexed, so for client_locations = ["TX", "AZ", "UT", "NY"], the indices are: 0 → "TX", 1 → "AZ", 2 → "UT", 3 → "NY".

The slice client_locations[1:3] starts at index 1 and stops before index 3. Therefore, it includes elements at indices 1 and 2, which are "AZ" and "UT". The result is ["AZ", "UT"].

This slice rule is heavily emphasized in programming textbooks because it supports efficient sub-list extraction and is consistent across Python sequence types such as strings and tuples. It also helps avoid off-by-one errors by using an exclusive end boundary. The exclusive stop index makes it easy to take “the first n items” via [0:n] and to split sequences at a boundary without overlap. In practical software development, slicing is widely used for batching data, windowing in algorithms, and parsing structured inputs, making it an essential Python skill.

Python usesdynamic typing, a core concept emphasized in programming language textbooks. In dynamically typed languages, a variable name does not permanently “own” a type. Instead, theobjectcreated by an expression has a type, and the variable becomes a reference to that object. Therefore, the type associated with a variable at any moment is determined by the value assigned to it. For example, after x = 7, x refers to an integer object. After x = "seven", the same name now refers to a string object. The type changes because the binding changes, not because the variable’s type declaration was edited.

Option A describesstatic typingsystems (common in languages like Java, C, or C++), where programmers declare types and compilers enforce them. Python does not require such declarations for ordinary variables. Option B is incorrect because type assignment is deterministic, not random. Option C is incorrect because Python does not default variables to strings; it assigns whatever type results from the right-hand-side expression.

This model is closely tied to Python’s runtime behavior: type checks occur during execution, and functions can accept values of different types as long as the operations used are valid (often discussed as “duck typing”). This flexibility supports rapid development, but also motivates careful testing and, in larger systems, optional type hints for documentation and tool support.