ACD200 Appian Certified Senior Developer Question and Answers

 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. 

 Creating a trigger on the database table to capture the audit trail to a table is the most efficient and has the least impact on the Appian application, because it avoids adding extra logic or calls to the Appian application, which could affect its performance and scalability. A trigger is a database object that automatically executes when a specified event occurs on a table or view. A trigger can be used to insert, update, or delete data from another table based on the changes made to the original table. References: [Triggers], [Audit Trail]

The first place to go to find more details on why the Send E-Mail node encountered an error is to investigate the application server stdout log. This log contains information about the email server configuration, connection status, and error messages. You can access this log from the Administration Console under Monitoring > Logs > Application Server Logs > stdout.log. You can also search for keywords like “email” or “smtp” to filter the relevant entries. References: [Send E-Mail Smart Service], [Application Server Logs]

The question is about choosing the right plug-in for a requirement that can only be achieved by using a plug-in. The following are three primary considerations in choosing the right plug-in:

• What are the compatible Appian versions? This is important because some plug-ins may not work with older or newer versions of Appian due to changes in APIs or features. You should check the plug-in documentation or release notes to see which Appian versions are supported by the plug-in.
• Is the plug-in Cloud-approved? This is important because some plug-ins may not be allowed in Appian Cloud environments due to security or performance reasons. You should check the Appian Cloud Approved Plug-ins list to see which plug-ins are approved for use in Appian Cloud.
• What are the limitations of the plug-in? This is important because some plug-ins may have known issues or limitations that could affect your requirement or use case. You should check the plug-in documentation or forums to see if there are any reported bugs or limitations for the plug-in.

The following are not primary considerations in choosing the right plug-in:

• What is the size of the plug-in? This is not a major factor, as plug-ins are usually small in size and do not affect the performance or storage of Appian significantly. However, you should still follow the best practices for managing plug-ins and avoid installing unnecessary or unused plug-ins.
• Who is the plug-in author? This is not a decisive factor, as plug-ins can be authored by Appian, third-party vendors, or community members. However, you should still consider the reputation and reliability of the plug-in author and check their support and update policies.

References:

• Plug-ins
• Appian Cloud Approved Plug-ins

The @Version annotation is used to avoid the collision of data from an application when more than one user is editing the same record in a database. The @Version annotation enables optimistic locking, which is a mechanism to detect and prevent concurrent updates on the same record. Optimistic locking assumes that multiple transactions can complete without affecting each other, and that therefore transactions do not need to lock data resources until they are ready to commit. However, if a transaction tries to commit changes to a record that has been modified by another transaction since it was last read, an OptimisticLockException is thrown and the transaction is rolled back. The @Version annotation can be applied to a field or property of a CDT that stores a numeric value. This value is used as a version number that is automatically incremented by Appian every time the record is updated. References: Does Appian support @Version JPA Annotation?, JPA - Optimistic Locking and Use of @Version annotation

 The type of plug-in that should be created to perform a job in the background and not be available under an expression rule, connected system, or the process model is a servlet plug-in. A servlet plug-in is a plug-in that allows you to create custom servlets that can be accessed through a URL. Servlets are Java classes that run on a web server and handle requests and responses. Servlet plug-ins can be used to perform background tasks, such as sending notifications, logging events, or integrating with external systems, without exposing them to the end users or developers. References: Servlet Plug-ins, Appian Suite Plug-ins

When building a process model that transforms a large data set, two things that should be ensured to include in the process model are an XOR gateway before the transformation node, to check for empty/null values, and a transformation applied with an expression rule that takes the data set as an input, and loops through the dataset using a looping function, such as foreach. These things can help to improve the performance and reliability of the process model. The XOR gateway can prevent unnecessary processing of empty or null data sets, which can save time and resources. The expression rule can perform the transformation in one transaction, instead of using multiple nodes or subprocesses, which can reduce the memory footprint and the database load of the process model. Therefore, the correct answers are B and D.

References:

• [XOR Gateway]
• [Expression Rules]
• [foreach() Function]

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 most efficient method to insert the deleted row of a table into a history table for audit purposes is Trigger. This is because a trigger is a database object that automatically executes a specified SQL statement when a certain event occurs on a table or view. A trigger can be defined to run before or after a delete operation on a table, and can access the deleted row using a special table called deleted. A trigger can perform the insertion of the deleted row into the history table without any additional logic or overhead from Appian. References: Triggers

When troubleshooting a process model instance with an error in a node, two options that can provide more information about the error are to view the Process Details dialog and to view the properties dialog of the affected node. The Process Details dialog shows the status, history, and variables of the process instance, as well as any errors or warnings that occurred during the execution. The properties dialog of the affected node shows the configuration, inputs, outputs, and expressions of the node, as well as any errors or warnings that occurred during the evaluation. These options can help to identify the cause and location of the error, and to apply any necessary fixes. Therefore, the correct answers are B and D.

References:

• [Process Details Dialog]
• [Properties Dialog]

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

The most appropriate testing method to achieve this using Appian is Unit Testing. This is because unit testing allows you to test individual components of your application, such as forms, rules, or expressions, in isolation from other components or dependencies. Unit testing can help you verify that your Related Action works as expected for different users and data scenarios, as well as identify and fix any errors or bugs before deploying your application to production. References: Unit Testing

 A materialized view is the best option to show joined data from 5 tables that contain a large number of rows and could generate a large result set after executing the joins. A materialized view is a physical table that holds the results of the SQL that a view would normally be constructed from and can be generated periodically. A materialized view can improve performance by reducing the execution time of complex queries that involve multiple joins, aggregations, or calculations. A materialized view can also reduce the load on the database server by storing the query results in advance. A materialized view can be refreshed at regular intervals or on demand to reflect the changes in the underlying tables. References: [Materialized Views], [View Performance]

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

A connected system is an Appian object that is designed to allow you to share base URL and authentication details across multiple integrations4. A connected system represents an external system that is integrated with Appian. Connected systems allow you to easily connect to external integrations and data sources. They also allow you to deploy connection information across environments and use different connection information for each environment. You can choose from different types of connected systems, such as HTTP, SQL, or pre-built connected systems for common services like Google Drive or Salesforce5.

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]

 Object security settings can be changed in bulk in the application security summary and the compare and deploy tool. The application security summary provides a centralized view of the security role maps for all objects in an application. You can filter, sort, and edit the role maps from this view. The compare and deploy tool allows you to compare objects between two environments and deploy changes from one environment to another. You can also edit the role maps of the objects before deploying them. References: Application Security Summary, Compare and Deploy Tool

The question is about the potential causes of a low completion rate of 10% for a process model. The following are two possible causes of this:

• The process instances are long-lived compared to the configured days until archival or deletion. This means that the process instances take a long time to complete, and they are archived or deleted before they reach the end event. This reduces the completion rate, as only the instances that reach the end event are counted as completed.
• A large number of instances are encountering process errors, and they are not being addressed by the production support team. This means that the process instances are stuck in an error state, and they cannot proceed to the next step or the end event. This reduces the completion rate, as only the instances that reach the end event are counted as completed.

The following are not likely causes of a low completion rate:

• A large value is configured for days until archival or deletion compared to other process models in your application. This means that the process instances have more time to complete before they are archived or deleted. This should increase the completion rate, as more instances can reach the end event before they are removed from the system.
• A large number of smart service nodes are configured in the process model. This means that the process model has a complex logic or functionality that requires multiple smart services. This does not directly affect the completion rate, as long as the smart services execute successfully and do not cause errors or delays.

References:

• Process Model Metrics
• Archiving and Deleting Process Instances

Three best practices that should be applied when code-checking a process model are:

• All XOR/OR gateways should have a single incoming flow. This is because XOR/OR gateways are used to split the process flow based on a condition or an event. Having multiple incoming flows to a gateway can cause confusion and ambiguity about the logic and order of execution. If multiple incoming flows are needed, they should be merged into a single flow using an AND gateway before reaching the XOR/OR gateway.
• All outgoing flows from a gateway should be labeled. This is because labels provide clarity and readability to the process model. They also help to document the business logic and rules that determine the path of execution. Labels should be concise, descriptive, and consistent throughout the process model.
• Node inputs should not make the same query call more than once. This is because repeated query calls can negatively impact the performance and efficiency of the process model. They can also cause data inconsistency and duplication if the query results change over time. Node inputs should use variables or rules to store and reuse query results whenever possible. References: Process Model Best Practices, Process Model Object, Process Modeling

The appian_log4j.properties file is used to configure the logging levels for Appian components, including authentication. You can modify this file to increase or decrease the verbosity of the log output for different categories. For example, to enable trace-level logging for SAML authentication, you can add this line to the file: log4j.logger.com.appiancorp.suite.authentication.saml=TRACE References: [Appian Logging Configuration], [SAML Troubleshooting]