The following is true for GlideUser (g_user) methods:
Can be used in Client Scripts, UI Policies, and UI Actions. This is true because GlideUser (g_user) methods are part of the client-side scripting APIs that provide information about the current user and the user’s preferences. Client Scripts, UI Policies, and UI Actions are all types of client-side scripts that run in the web browser and manipulate the user interface.
The following are not true for GlideUser (g_user) methods:
Can be used in Client Scripts and UI Policies only. This is false because GlideUser (g_user) methods can also be used in UI Actions, which are another type of client-side scripts that can be triggered by a user’s click on a button, link, or choice.
Can be used in Business Rules only. This is false because GlideUser (g_user) methods cannot be used in Business Rules, which are server-side scripts that run on the ServiceNow platform and manipulate the database. Business Rules use a different API to access the current user information, which is GlideSystem (gs).
Can be used in Business Rules, and Scripts Includes. This is false because GlideUser (g_user) methods cannot be used in Business Rules or Script Includes, which are both server-side scripts. Script Includes are reusable units of code that can be called from any server-side script. Script Includes also use GlideSystem (gs) to access the current user information. Reference: Client-Side Scripting APIs, GlideUser, Business Rules, Script Includes

The statement that is not true for Modules is that every Module must be associated with a table. A Module is the functionality within an Application Menu that opens a content page in the content frame or a separate tab or window. A Module can be associated with a table, a list, a form, a report, a script, or any other type of page.
For example, the Open Module under the Incident Application Menu opens a list of incident records from the Incident table, while the Overview Module under thePerformance Analytics Application Menu opens a dashboard page with various charts and widgets. The other statements are true for Modules. Access to Modules is controlled with roles, as each Module can have one or more roles specified in its definition that determine who can see and access it. Modules open content pages, as they are links to different types of pages that provide information and functionality to users. Every Module must be part of an Application Menu, as they are the second-level navigation options for Applications. Reference: Modules

In ServiceNow, extending a table means creating a new table (child class) that inherits properties from an existing table (parent class). This inheritance includes fields, business logic, and other configurations, allowing for efficient reuse and customization.
Key Points:
* Field Inheritance: The child table inherits all fields from the parent table. For example, if you extend the Task table, your new table will include fields like “short_description” and “priority.”
* Business Logic Inheritance: The child table also inherits business rules, client scripts, and other logic defined on the parent table, ensuring consistent behavior across related tables.
* Access Controls: Access controls are not ignored; instead, the child table inherits the parent table’s access controls. However, you can define additional access controls specific to the child table as needed.
* Customization: While the child table inherits many properties, you can add new fields, scripts, and behaviors to tailor it to specific requirements without affecting the parent table.
Reference: For more detailed information, please refer to the official ServiceNow documentation on Table Extension and Classes.

In ServiceNow, when developing within a privately-scoped application, certain logging methods are recommended for use in server-side scripts to ensure proper logging and debugging. The GlideSystem (gs) object provides several methods for this purpose:
* gs.debug():
* Description: Logs messages at the “Debug” level.
* Usage: gs.debug(‘Debug message here’);
* Purpose: Useful for logging detailed information during development and troubleshooting.
These messages are typically only visible when the system’s logging level is set to “Debug.”
* gs.error():
* Description: Logs messages at the “Error” level.
* Usage: gs.error(‘Error message here’);
* Purpose: Used to log error messages that indicate a problem that might still allow the application to continue running.
* gs.warn():
* Description: Logs messages at the “Warning” level.
* Usage: gs.warn(‘Warning message here’);
* Purpose: Used to log potentially harmful situations that are not necessarily errors but may require attention.
* gs.info():
* Description: Logs messages at the “Information” level.
* Usage: gs.info(‘Information message here’);
* Purpose: Used to log informational messages that highlight the progress of the application at a coarse-grained level.
Deprecated or Unsupported Methods in Scoped Applications:
* gs.log():
* Description: This method is not supported in scoped applications. It is restricted to the global scope and is not accessible from a private scope. Therefore, it should be avoided in privately- scoped applications.

“A table that extends another table is called a child class, and the table it extends is the parent class” – this is about halfway down in this link below:https://docs.servicenow.com/en-US/bundle/tokyo-platform-administration/page/administer/table-administ

Business Rule is server-side, so it uses GlideSystem API. gs.hasRoleExactly doesn’t exist

In ServiceNow, the Application Picker is a user interface element that allows developers to select the active application they are working on. The selected application determines the Application Scope, which defines the boundaries within which application artifacts (like tables, scripts, and UI components) reside and operate.
* A. Selecting Global in the Application Picker sets the Application Scope to Incident: This is incorrect.
Selecting “Global” sets the scope to the global application, not specifically to the Incident application.
* B. Global is a reserved application that does not appear in the Application Picker: This is incorrect. The
“Global” application is available in the Application Picker and represents the global scope.
* C. Selecting an application from the Application Picker sets the Application Scope: This is correct.
Choosing an application from the Application Picker establishes that application’s scope as the current context for development and configuration.
* D. Selecting an application from the Application Picker does not set the Application Scope: This is incorrect. The Application Picker directly influences the current Application Scope.
For more information, refer to the official ServiceNow documentation on Application Scope.
For a visual demonstration of restricting access to your ServiceNow application, you may find the following video helpful:
Restricting Access to your ServiceNow App

In ServiceNow, the GlideSystem (gs) object provides several methods for logging messages in server-side scripts. In a privately-scoped application, the following methods are commonly used:
* A. gs.log(): This method logs a message to the system log (syslog table). It is a general-purpose logging method that allows developers to record informational messages.
* E. gs.info(): This method logs informational messages to the system log. It is functionally similar to gs.
log() but is specifically intended for informational messages.
The other options are not standard methods provided by the GlideSystem object:
* B. gs.error(): This method does not exist in the GlideSystem API.
* C. gs.debug(): This method does not exist in the GlideSystem API.
* D. gs.logError(): This method does not exist in the GlideSystem API.
For more detailed information, refer to the official ServiceNow documentation on the GlideSystem API.

Catalog Client Scripts and Catalog UI Policies are the client-side scripts that apply to Record Producers. Catalog Client Scripts allow you to add or modify functionality on a catalog item or record producer form. Catalog UI Policies dynamically change information on a catalog item or record producer form. UI Scripts, UI Actions, Client Scripts, and UI Policies do not apply to Record Producers. Reference: Catalog client scripts, Catalog UI policies

In ServiceNow, when a new field is added to an existing table, it is not automatically included in any existing List views. List views are predefined configurations that determine which fields are displayed when viewing records in a list format. To display the new field in a List view, you must manually modify the List layout to include the field.
Steps to Add a New Field to a List View:
* Navigate to the List Layout Configuration:
* Go to the table’s list view.
* Right-click on the header row (where the column titles are displayed).
* Select “Configure” and then “List Layout.”
* Add the New Field:
* In the List Layout configuration, you’ll see two columns: “Available” and “Selected.”
* Locate your new field in the “Available” column.
* Use the arrow buttons to move the new field to the “Selected” column, placing it in the desired order.
* Save the Configuration:
* Click “Save” or “OK” to apply the changes.
* The new field will now appear in the List view as configured.

Comprehensive and Detailed Step-by-Step Explanation:
* Understanding Application Scope and Picker:
* The Application Picker in ServiceNow allows developers to switch between different applications (scopes).
* When you select an application from the Application Picker, the Application Scope is set to that application, enabling you to develop or configure within that scope.
* Why Other Options Are Incorrect:
* Option A: The Global application does appear in the Application Picker.
* Option B: Selecting Global does not set the scope to Incident; it sets the scope to the Global application, which is not restricted by scoped boundaries.
* Option D: Selecting an application does indeed set the Application Scope.
References:
* ServiceNow Developer Documentation on Application Scope.

https://docs.servicenow.com/bundle/tokyo-application-development/page/build/applications/concept/c_Applicati

When configuring a REST Message, the Endpoint is:
The URI of the data to be accessed, queried, or modified. This is the correct answer because the Endpoint is the part of the REST Message that specifies the location and the resource of the REST provider. The Endpoint is composed of the base URL and the resource path, which can include query parameters or variables. For example, the Endpoint for a REST Message that retrieves the weather information for a city from a web service could be https://api.openweathermap.org/data/2.5/weather?q=London.
The following are not correct definitions of the Endpoint when configuring a REST Message:
The commands to the REST script to stop execution. This is not correct because the commands to the REST script to stop execution are not part of the REST Message, but of the Scripted REST API, which is a feature that allows users to create custom REST endpoints on the ServiceNow platform. The commands to the REST script to stop execution are methods of the RESTAPIResponse object, such as setStatusCode, setError, or complete.
Information about the format of the returned data. This is not correct because the information about the format of the returned data is not part of the Endpoint, but of the HTTP headers or the Accept field of the REST Message. The HTTP headers or the Accept field can be used to specify the content type of the response, such as JSON, XML, or HTML.
The response from the provider indicating there is no data to send back. This is not correct because the response from the provider indicating there is no data to send back is not part of the Endpoint, but of the HTTP status code or the response body of the REST Message. The HTTP status code or the response body can be used to indicate the result of the REST request, such as 200 OK, 404 Not Found, or 500 Internal Server Error. References: REST Messages, Scripted REST APIs