Free Appian ACD200 Practice Exam with Questions & Answers | Set: 2

The question is about referencing and using arrays of a CDT (Custom Data Type). The following statements are true:

• There is no difference between using “dot notation” and the index() function. Both methods can be used to access elements of an array by their position. For example, if a is an array of CDTs, then a[1] and index(a, 1) will return the same element.
• An array of integers can be passed as the second parameter to the index() function to return the data at those positions in the array. For example, if a is an array of CDTs, then index(a, {1, 3, 5}) will return an array of CDTs containing the elements at positions 1, 3, and 5 in a.

The following statements are false:

• Other Appian functions can be used within the square brackets “[]” when using dot notation to return specific data from the array. This is not possible, as dot notation only accepts integers or integer arrays as indices. For example, if a is an array of CDTs, then a[length(a)] will cause an error, as length(a) is not a valid index.
• The function wherecontains can act on operands of different types. This is not true, as wherecontains only works on operands of the same type. For example, if a is an array of CDTs and b is an array of integers, then wherecontains(a, b) will cause an error, as a and b are not of the same type.

References:

• Dot Notation
• index()
• wherecontains()

The instances of the process model that will be affected by modifying the automatic process clean-up settings are future and past instances of the process model. The automatic process clean-up settings allow you to specify how long completed or canceled processes should be kept before being archived or deleted. These settings apply to all instances of the process model, regardless of when they were started or completed. However, these settings do not affect any subprocesses that are part of the process model. Subprocesses have their own archival settings that can be configured separately. References: Automatic Process Clean-up Settings, Archiving Processes

 The Number (Integer) data type should be chosen for the BOOK_ID, because it is a unique identifier for each book record. The Number (Integer) data type is used to store whole numbers without decimals, such as IDs, counts, or ordinal values. The Number (Integer) data type can also be used as a primary key for a CDT or a foreign key for referencing another CDT. References: [Number (Integer) Data Type], [CDT Primary Keys]

 Two true statements are:

• It is not possible to undo changes from an import to all types of objects. Once a package is imported to an environment, it applies changes to the existing objects or creates new objects based on the package contents. There is no built-in mechanism to revert these changes or delete these objects automatically. Therefore, it is important to test the package in a non-production environment before importing it to production, and to backup any objects that may be overwritten by the import.
• It is possible to import the same package multiple times. A package can be imported to an environment more than once, as long as it does not contain any conflicts or errors that would prevent the import. However, importing the same package multiple times may not have any effect if there are no changes in the package contents or in the target environment since the last import. References: Prepare Deployment Packages, Application Deployment Guidelines

The two statements about the a!queryEntity() function that are true are:

• The entity value must be given as a constant of type Data Store Entity. This is because the entity value specifies which data store entity (table or view) to query from. The value must be a constant that references an existing data store entity in Appian Designer. You cannot use a variable or an expression for this value.
• Setting the fetchTotalCount parameter to False can improve the performance of the rule. This is because setting this parameter to False tells Appian not to calculate the total number of records that match the query criteria, which can be an expensive operation for large data sets. By default, this parameter is set to True, which means Appian will return the total count along with the query results. References: a!queryEntity() Function

 The question is about troubleshooting slow response times on a SAIL interface. The following are two potential causes of the performance issues:

• Multiple a!save operations: This means that the interface has multiple expressions that use a!save to store data in variables or update components. This can cause performance issues, as each a!save operation triggers a server round-trip and refreshes all dependent components on the interface. You should minimize the use of a!save operations and use local variables or component parameters instead.
• Configuration of refresh variables: This means that the interface has components that use refresh variables to control when they should be refreshed based on changes in other components or variables. This can cause performance issues, as some components may be refreshed unnecessarily or too frequently due to incorrect or excessive refresh variables. You should optimize the refresh variables and use them only when needed.

The following are not likely causes of slow response times on a SAIL interface:

• Multiple rule inputs: This means that the interface has expressions that use rule inputs to pass data or parameters to expression rules. This does not affect the performance of the interface, as rule inputs are evaluated on the server and do not cause additional server round-trips or refreshes.
• Stacked button layout: This means that the interface has a layout component that arranges buttons in a vertical stack. This does not affect the performance of the interface, as it is a simple layout component that does not require any server interaction or refresh logic.

References:

• a!save()
• Refresh Variables
• Rule Inputs
• Stacked Button Layout

The best process model design for a case management application is to use a case record and a related action. This way, the process flow does not have to wait for the reviewer to complete the task, which can take up to 7 days. This reduces the memory impact of the process, as well as the risk of process timeouts or errors. The case record also provides a better user experience, as the reviewer can access the case details and the related action from one place. Therefore, the best answer is A.

References:

• Case Management
• Related Actions

The question is about initiating a process via an Appian web API. The HTTP request method that the API should use is POST, as it is the method that allows sending data to the server and creating or updating a resource. In this case, the data would be the process parameters and the resource would be the process instance. The other options are not suitable for this purpose, as they either do not allow sending data or do not create or update a resource. References:

• HTTP Request Methods
• Start Process Web API

 The question is about AMUs (Appian Memory Units), which is a metric that measures the memory usage of a process model. The following statement is correct regarding this metric:

• Memory usage is considered low when it is below 100,000 AMUs. This is based on the Appian recommendation that each process model should use less than 100,000 AMUs on average, as higher memory usage can affect the performance or stability of Appian.

The following statements are not correct regarding this metric:

• Memory usage is considered low when it is below 10,000 AMUs. This is too low, as most process models will use more than 10,000 AMUs on average, depending on their complexity and data size.
• Memory usage is considered low when it is below 1,000 AMUs. This is too low, as even simple process models will use more than 1,000 AMUs on average, depending on their configuration and parameters.
• AMUs is not a good measurement for process memory usage. This is not true, as AMUs is a standardized and consistent measurement that reflects the relative memory usage of different process models in Appian.

References:

• AMUs (Appian Memory Units)

The question is about allowing external systems to invoke Appian web APIs. A service account is the user role that should be used for this purpose, as it is a special type of basic user that can be configured to authenticate with web APIs using an API key. A service account can also be assigned to specific groups or roles to control the access to web APIs. The other options are not user roles, but rather groups or user types that are not suitable for this purpose. References:

• Service Accounts
• Web API Security