ACD200 Exam Dumps - Appian Senior Developer Questions and Answers

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

 Two things that can be done to increase the performance of a poorly-performing process model that has a lot of nodes and is mainly used to do background updates are:

• Remove all activity chaining. Activity chaining is a feature that allows a process to move from one node to another without waiting for a commit point. This can improve the performance of some processes, but it can also cause memory issues and data inconsistency if used excessively or incorrectly. Removing activity chaining can reduce the memory consumption and ensure data integrity of the process model.
• Refactor some nodes into subprocesses when possible. Subprocesses are processes that are called from within another process model. Refactoring some nodes into subprocesses can simplify the main process model and improve its readability and maintainability. It can also reduce the memory usage and execution time of the main process model, as subprocesses are executed in parallel and have their own memory allocation. References: Activity Chaining, Subprocess Node, Process Model Best Practices

The question is about a sign that an application’s performance is degrading and should be addressed with changes to the application design. The following is a sign of this:

• Three of the top five most executed process models have a low completion percentage. This means that a large proportion of the process instances are not reaching the end event, either because they are taking too long to complete, or because they are encountering errors or exceptions. This can affect the performance of the application, as it can consume more memory and resources, and reduce the availability and reliability of the application. You should review the process model design and identify the causes of the low completion rate, and make changes to improve the process efficiency and error handling.

The following are not signs of performance degradation that require changes to the application design:

• Integration calls to an external system are consistently returning an HTTP status code of 500. This means that the external system is experiencing an internal server error, which is not related to the application design. You should contact the external system provider and report the issue, or implement a fallback or retry mechanism in your integration logic.
• The number of tasks assigned to users has increased from 1 per day to 5 per day. This means that the workload or demand for the application has increased, which is not necessarily a sign of performance degradation. You should monitor the task completion rate and user feedback to see if the increase in tasks is affecting the user experience or satisfaction, and adjust the task assignment or prioritization logic if needed.
• The number of objects in the Application has increased from about 100 to about 500. This means that the application has grown in size and complexity, which is not necessarily a sign of performance degradation. You should follow the best practices for application design and maintenance, such as using folders, prefixes, dependencies, and documentation, to keep the application organized and manageable.

References:

• Process Model Metrics
• HTTP Status Codes
• Task Report
• Application Design

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 most appropriate action to display a Gender dropdown whose choice label may change in the future as per the business requirement is to create these entries in a table and reference them through a query entity rule as per the business requirement. This is because storing the choice labels in a table allows for easy maintenance and modification of the data without affecting the transactional database tables that rely on this data for reporting. Using a query entity rule allows for retrieving the data from the table and populating the dropdown component dynamically and consistently across different interfaces or processes that use this data. References: Dropdown Component, Query Entity Rule, Data Management

 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

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]

 According to Appian best practices, the preferred style and size for the images to display the profile picture of each employee inside an employee grid are style: “AVATAR” and size: “SMALL”. This is because the avatar style creates a circular image that is suitable for profile pictures, and the small size creates a 32x32 pixel image that fits well inside a grid cell. The standard style creates a rectangular image that may not look good for profile pictures, and the large size creates a 128x128 pixel image that may be too big for a grid cell. References: Image Component

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]

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