ACD200 Online Practice Questions and Answers

Correct Answer: C

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

Correct Answer: BC

Two places to get information on process model memory usage are: Process monitoring tab. The process monitoring tab is a feature in the Appian Designer that allows you to monitor and manage the performance and status of process models and instances. You can use the process monitoring tab to view various metrics and statistics about your processes, such as memory usage, execution time, node count, error count, etc. You can also filter, sort, and export the data for further analysis. The process monitoring tab can help you identify which processes have the highest memory footprint and potential performance issues. Appian Health Check report. The Appian Health Check report is a tool that provides insights into application design patterns and performance risks in your environment. The report covers four areas of your environment: design, user experience, infrastructure, and configuration. The report also includes graphs highlighting historical trends, such as user activity, average response times, and resource utilization. The Appian Health Check report can help you identify which processes have the highest memory consumption and suggestions for mitigating them. References: Process Monitoring Tab, Understanding the Health Check Report

Correct Answer: BC

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()

Correct Answer: D

A many-to-many relationship is a type of relationship where multiple records in one table are associated with multiple records in another table. To implement a many-to- many relationship, a third table is needed to store the associations between the two entities. In this case, the third table would store the employee ID and the skill ID for each pair of employee and skill. This design allows for efficient querying and updating of the data, as well as avoiding data redundancy and inconsistency.

Correct Answer: AC

An index is a data structure that allows for faster retrieval of data from a table based on one or more columns. Indexes increase the performance of read operations, such as select queries, by reducing the number of records that need to be scanned. However, indexes decrease the performance of write operations, such as insert, update, and delete queries, by requiring additional work to maintain the index structure and ensure its consistency with the table data. Therefore, indexes should be used judiciously and only on columns that are frequently used in queries and have high selectivity (i.e., low number of duplicate values).

Correct Answer: A

A joining table can be used to hold instances of Student/Class relationships, so that it can be supported in Appian and remain in at least First Normal Form. A joining table is a table that contains only foreign keys that reference the primary keys of other tables. A joining table can be used to model a Many-to-Many relationship between two entities, such as Student and Class. For example, a joining table called Enrollment could have two columns: Student_ID and Class_ID, which reference the primary keys of the Student and Class tables respectively. Each row in the Enrollment table represents an instance of a student enrolled in a class. References: [Joining Tables], [Many-to-Many Relationships], [First Normal Form]

Correct Answer: C

The correct representation of Appian best practices for using pie charts is to use pie charts to show proportional data. Pie charts are generally used to show how individual parts contribute to a whole, such as percentages or fractions. Pie charts should only be used to represent data that can be placed into distinct categories and should not consist of more than 6 slices. Pie charts should also include value and category labels for each slice, and sort the data values in ascending or descending order. References: Pie Chart Component, Charts UX Design Guide

Correct Answer: C

The question is about designing a process model to store the result of an expression rule for every item in a list with the lowest memory footprint. The best design for this purpose is to configure a script task to use a!foreach to iterate over each item in the list, as it allows you to execute an expression rule for each element of an array without creating multiple nodes or subprocesses in the process model. A script task is a node that executes an expression without user interaction, and a!foreach is a function that applies an expression to each element of an array and returns an array of results. The other options are not optimal for this purpose, as they either create more nodes or subprocesses in the process model, which consume more memory and resources. References: Script Task a!foreach()

Correct Answer: C

The likely cause for a task on a newly-launched process in Production being slow to respond to user input is having too many SAIL components on the task. SAIL components are the UI elements that make up an interface in Appian. Having too many SAIL components on a task can negatively impact the performance and user experience of the interface, as it increases the rendering time and complexity of the interface. It can also cause browser compatibility issues or memory leaks. It is recommended to limit the number of SAIL components on a task to less than 100, and to use grids, collapsible layouts, or tabs to organize and display data efficiently. References: SAIL Components Overview, SAIL Performance Tips

Correct Answer: BCE

The three actions that can be taken to minimize the performance impact of the Tempo report are: Limit the number of series values and categories in the report. This is because having too many series values and categories can make the report difficult to read and render, as well as increase the amount of data that needs to be transferred from the database to Appian. A good practice is to limit the number of series values to 10 or less, and the number of categories to 20 or less. Use local variables in your report interface to avoid redundant database queries. This is because local variables can store the results of database queries and reuse them in multiple places within the interface, reducing the number of times the database is accessed. A good practice is to use local variables for common filters, aggregations, or calculations that are used in multiple charts or grids. Perform aggregation in the database using a view prior to reading the data into Appian. This is because performing aggregation in the database can reduce the amount of data that needs to be transferred from the database to Appian, as well as leverage the database's optimization capabilities. A good practice is to create a view in the database that performs the aggregation and then query that view using Appian. References: Report Performance Best Practices