ACD200 Appian Certified Senior Developer Questions and Answers

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]

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.

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

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

 Activity chaining is a feature that allows users to complete multiple tasks in a row without returning to their task list. However, activity chaining can also have some drawbacks, such as increased memory consumption, longer transaction times, and reduced user feedback. Therefore, some practices are strongly discouraged for activity chaining, such as having more than 50 node instances or more than 5 seconds between attended activities. These practices can cause performance issues, user frustration, or process failures. Therefore, the correct answers are B and C.

References:

• Activity Chaining
• Performance Best Practices

Three methods that could be used to launch a test run for expression rule test cases when required are:

• A process model invoked via an API. A process model can be designed to run test cases for expression rules using the a!testRule() function or the Test Rule smart service. This process model can be exposed as a web API with an HTTP method such as POST or PUT, allowing external systems or applications to invoke it through an HTTP request.
• A process model exposed to users as an action. A process model can also be designed to run test cases for expression rules using the same function or smart service as above. This process model can be exposed to users as an action on an interface, such as a button or a link, allowing users to trigger it manually when needed.
• A SAIL interface embedded in a report. A SAIL interface can be created to run test cases for expression rules using the a!testRule() function. This interface can be embedded in a report, such as a grid or a chart, allowing users to view the test results interactively on an interface. References: Automated Testing for Expression Rules, a!testRule() Function, Test Rule Smart Service, Web APIs, SAIL Interfaces

 The minimum privilege the end user should have to execute a web API is Viewer. A web API is an Appian object that exposes data and services to outside systems through an HTTP endpoint. A web API can be configured with different security role maps that control which users can see or modify it and its properties. A user must have at least Viewer permissions to a web API in order to execute it. Viewer permissions allow the user to view and run the web API, but not to edit or delete it. References: Web APIs, Web API Security

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 requirement is to use space efficiently in a user interface where the meaningful order of components is vertical. A columns layout is the most appropriate layout component for this requirement, as it allows you to arrange components into columns that stack vertically on smaller devices. A columns layout also provides options to control the width, alignment, and visibility of each column. The other options are not suitable for this requirement, as they either do not preserve the vertical order of components or do not use space efficiently. References:

• Columns Layout

 Peer Dev Review is the most efficient way to coach team members and improve code quality, because it allows developers to share feedback, learn from each other, and identify and fix issues before they become problems. Peer Dev Review also fosters collaboration, communication, and best practices among the team. Peer Dev Review can be done using tools like Appian Designer or Appian Code Review. References: [Peer Dev Review], [Appian Code Review]

 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]

 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. 

The question is about approving or rejecting an incoming deployment. The following roles allow you to do so:

• Specified Reviewer Group: This is a group that can be specified by the application administrator when creating a deployment package. Members of this group can approve or reject the deployment package in the target environment.
• System Administrators: This is a group that has full access and control over all applications and system settings in Appian. Members of this group can approve or reject any deployment package in any environment.
• Application Administrators Group: This is a group that has full access and control over a specific application in Appian. Members of this group can approve or reject any deployment package for their application in any environment.

The following roles do not allow you to approve or reject an incoming deployment:

• Application Viewers: This is a group that has read-only access to a specific application in Appian. Members of this group cannot approve or reject any deployment package for their application in any environment.
• Application Editors: This is a group that has edit access to a specific application in Appian. Members of this group can create and export deployment packages for their application in any environment, but they cannot approve or reject them.

References:

• Deploying Applications
• Application Roles

References:

• [Web APIs]
• [Connected Systems]
• [Expression Rules]
• [Decision Tables]

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]

Three possible reasons for high memory consumption of a process model are:

• Too many process variables. Process variables are used to store data that is needed throughout the process execution. However, having too many process variables can increase the memory usage of the process engine, especially if the variables store large or complex data types, such as documents or CDTs. It is recommended to use local variables whenever possible, and to delete or nullify process variables that are no longer needed.
• Nested CDTs with large numbers of fields. CDTs are custom data types that define the structure and validation of business data in Appian. CDTs can be nested within other CDTs to create complex data models. However, nesting CDTs with large numbers of fields can result in high memory consumption and performance degradation, as each field requires additional memory allocation and processing. It is recommended to limit the number of fields and nesting levels of CDTs, and to use references instead of embedding whenever possible.
• Too many nodes. Nodes are the graphical elements that represent the activities and events in a process model. Having too many nodes in a process model can increase the memory usage and complexity of the process execution. It can also make the process model harder to read and maintain. It is recommended to simplify the process model by using subprocesses, smart services, or expression rules to encapsulate common or reusable logic. References: Process Variables, Custom Data Types, Process Model Best Practices

The question is about the testing tools that have packages preconfigured to work with Appian applications and are available via the AppMarket. The following are three testing tools that meet these criteria:

• Cucumber: This is a tool that supports Behavior-Driven Development (BDD) and automated testing by allowing users to write test scenarios in plain language and execute them using step definitions. Cucumber has a package called Appian Cucumber Test Framework that provides a set of predefined step definitions and helper methods for testing Appian applications.
• Selenium API: This is a tool that allows users to automate web browser interactions and test web applications. Selenium API has a package called Appian Selenium Framework that provides a Java library and a set of helper methods for testing Appian applications.
• FitNesse: This is a tool that allows users to create and run acceptance tests using wiki pages and tables. FitNesse has a package called Appian FitNesse Testing Framework that provides a set of fixtures and helper methods for testing Appian applications.

The following are not testing tools that have packages preconfigured to work with Appian applications and are available via the AppMarket:

• Jenkins: This is a tool that allows users to automate software development tasks such as building, testing, and deploying applications. Jenkins does not have a package specifically for Appian applications, but it can be integrated with other testing tools such as Cucumber or Selenium API.
• Git: This is a tool that allows users to manage version control and collaboration for software projects. Git does not have a package specifically for Appian applications, but it can be used to store and share test scripts or scenarios created by other testing tools.

References:

• AppMarket
• Cucumber
• Selenium API
• FitNesse

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