89i

Index of first array element is...

0

Package

An automation project published as a NuGet package from the Studio family to Orchestrator or locally.

Digital Transformation

Digital transformation can be anything from IT infrastructure modernization to optimization or new digital business models.

Purpose of a selector

It contains GUI element details in the shape of XML fragments that help identify UI elements.

For Each

It performs an activity or a series of activities on each element of an input collection. This is very useful in data processing. Consider an Array of integers. For Each would enable the robot to check whether each numeric item fulfills a certain condition.

RPA Support Engineer -

Manage the robots after the processes have been moved to production, with support from the original RPA devs who have performed the automation. May have multiple levels of support: L1- Client, L2- client/ partner, (L0 - Super users; L3 - UiPath).

4 Categories of Automation Potential

No RPA Semi Automation (some manual) High Cost RPA (complex) Zero Touch Automation (simple automations)

Array example

StringArray = {"John", "Doe"}

Control Flow Statements

The activities and methods used to define the decisions to be made during the execution of a workflow.The most common control flow statements are If, While, Do While, For Each, Switch, and Parallel. We will focus on them one by one.

Procedure Explains...

who is responsible for each part of the process when each part of the process needs to occur how to handle exceptions the specifications applicable to each part of the process.

Workflow & Workflow Layouts

)A workflow represents a small piece of automation that you can take and re-use in your projects. It is basically your canvas, the place where you design and work with all the UiPath Studio activities and it defines the flow of your automation. Hence the name, workflow. 1. Sequences (linear processes, reusable) 2. Flowcharts (branching logical operations to create complex processes and connect activities in multiple ways, reusable) 3. State Machines (finite number of states, It can go into a state when it is triggered by an activity, and it exits that state when another activity is triggered, transitions: can add conditions based on which to jump from one state to another (arrows or branches) 4. Global Exception Handler (The Global Exception Handler is a type of workflow designed to determine the project's behavior when encountering an execution error. Only one Global Exception Handler can be set per automation project. errorInfo & result arguments)

Orchestrator Jobs

- A job represents the execution of a process on a UiPath Robot. You can launch the execution of a job in either attended or unattended mode. You cannot launch a job from Orchestrator on attended robots, unless for debugging purposes using personal workspaces, and they cannot run under a locked screen.

6 Stages of RPA Implementation

1. Prepare 2. Solution Design 3. Build RPA 4. Test RPA 5. Stablize RPA - move to prod 6. Constant Improvement

Data Types

1. String = System.String: Used to store text. 2. Numeric (Category) = Used to store numbers. There are different sub-types of numerical variables. For a few examples: Int32 - System.Int32 (signed integers): 10, 299, -100, 0x69 Long - System.Int64 (long integers): 5435435343O, -11332424D Double - System.Double (allows decimals, 15-16 digits precision): 19.1234567891011 3. Boolean = System.Boolean: Used to store one of two values - True or False. 4. Collection (category) = This category reunites all the collections of objects. Collections are largely used for handling and processing complex data. Some of the most encountered collections are: Array - ArrayOf<T> or System.DataType[]: used to store multiple values of the same data type. The size (number of objects) is defined at creation. List - System.Collections.Generic.List<T>: used to store multiple values of the same data type, just like Arrays. Unlike Arrays, their size is dynamic. Dictionary - System.Collections.Generic.Dictionary<TKey, TValue>: used to store objects in the form of (key, value) pairs, where each of the two can be of a separate data type. 5. DataTable = DataTable variables represent a type of variable that can store big pieces of information, and act as a database or a simple spreadsheet with rows and columns. 6. DateTime = DateTime - System.DateTime: Used to store specific time coordinates (mm/dd/yyyy hh:mm:ss).This kind of variable provides a series of specific processing methods (subtracting days, calculating time remaining vs. today, and so on).For example, to get the current time, assign the expression DateTime.Now to a variable of type DateTime. TimeSpan - System.TimeSpan: Used to store information about a duration (dd:hh:mm:ss). You can use it to measure the duration between two variables of the type DateTime.For example, you can save the time at the start of the process in one variable (of type DateTime), the time at the end in another (of type DateTime) and store the difference in a variable of type TimeSpan. 7. GenericValue = This is a UiPath proprietary variable type that can store any kind of data, including text, numbers, dates, and arrays. This type is mainly used in activities in which we are not sure what type of data we will receive, yet in general the use of this is temporary.

Selector Tags/Attributes

<webctrl parentid='slide-list-container' tag='A' aaname='Details' class='btn-dwnl' /> Nodes in the selector XML fragment Correspond to a visual element on the screen First node is the app window Last node is the element itself For example: wnd (window) html (web page) ctrl (control) webctrl (web page control) java (Java application control) Every attribute has a name and a value. You should use only attributes with constant or known values. For example: parentid='slide-list-container' tag='A' aaname='Details' class='btn-dwnl'

Automation Project

A business process or task automated with Studio family. Depending on the complexity and development approach, an automation project may consist of one or several workflows. A workflow is a set of actions following a given logic set by the developer, having an input and an output. Workflows are typically linked in the same automation project through input and output arguments.

Process

A package in Orchestrator linked to an Orchestrator folder where human users or robots have access. If stored locally, packages can be used as processes when they are run by attended robots.

Business Process

A process is a set of interrelated or interacting activities that transforms inputs into outputs.

Unattended Robot

A robot typically deployed on a separate machine than any human user. Their jobs are triggered exclusively from Orchestrator. Since robots do not exist as separate entities in Orchestrator, a more technical definition would position unattended robots as execution slots - a user logged in on a machine, executing an automation job, as instructed by Orchestrator.

Selectors

A selector in UiPath Studio is a feature that enables the identification of a specific User Interface element through its address and attributes. These are stored as XML fragments. The element identification is done to perform specific activities in an automation project. Selectors are generated automatically every time we use an activity that interacts with graphical user interface elements. We can think of the element identification process achieved through selectors as a postman that delivers letters to a certain address. In order for the postman to deliver the letters, a specific path is required and must contain structured and hierarchized details such as Country > City > Zip Code > Street Name > Street Number > Apartment Number. Similarly, UiPath Studio requires the detailed path to a specific element within the user interface.

Job

A single execution of an automation process by an attended or unattended robot. If the robots are connected to Orchestrator, both attended and unattended jobs appear there.

UiPath Robot

A software robot is an execution agent that runs automations built with the Studio family and then published as packages either locally, or to Orchestrator.

Attended Robot

A type of robot working on the same machines as the humans, during the same hours. They are triggered directly by humans (usually through UiPath Assistant) or by an event related to what the human user does.

Manipulating Lists

Add/Remove from collection, exists in collection, clear collection

Difficult Situations

Anchor Base: This is very useful in cases in which the attribute values are not reliable (are generated at each execution, for example), but there is a UI element that is stable and is linked to the target UI element. The Anchor Base activity has two parts, one to locate the anchor UI element (like 'Find Element'), and the second to perform the desired activity Relative Selector: This activity will basically incorporate the information about the anchor's selector in the selector of the target UI element. However, the new selector will probably need additional editing, as some nodes of the first selector will still be in the new one. The solution is to have that part (like a dynamic ID) removed, and the selector will stabilize using the anchor's selector. Visual Hierarchy Tree: The hierarchy in the Visual Tree can improve the reliability of a selector by including the tags and attributes of the element that is above in the hierarchy. This is very useful when the target UI element's selector is not reliable, but the selector of the UI element right above in the hierarchy is. However, again, the selector needs further editing and validation, as the dynamic part needs to be removed and, at the same time, you need to make sure that the target element can be identified with a unique attribute. Find children: This activity can identify all the children of an element that is more stable. Since its output is the collection of children, you will need to come up with a mechanism to identify only the target UI element (using one of its attributes, that makes is unique between the children, but wouldn't be enough to identify it universally).

Arguments

Args store data dynamically like variables, have the same data types as variables, and support the same methods and properties as variables The difference is that they pass data between workflows, and they have an additional property for this - the direction. Arguments have specific directions: In, Out, and In/Out. These tell the Robot where the information stored in them is supposed to go.

DateTime

As the name implies, the DateTime type (System.DateTime) enables you to store information about dates and times in variables.This type of variable can be found in the Browse and Select a .Net type window, under the System namespace System.DateTime. Typical uses of DateTime variables include appending documents or performing time span calculations.

Orchestrator Heartbeat

Attended and unattended robots send a heartbeat to Orchestrator every 30 seconds. This signals to Orchestrator that the connection is working.

Which type of robot can you provision by using the sign in feature?

Attended robots

Which of the following statements about robots are false?

Attended robots cannot run automation processes published to Orchestrator THIS ONE Attended users can run automation jobs using UiPath Assistant Unattended robots are typically deployed on separate machines You can run jobs from Orchestrator both on attended and unattended robots THIS ONE

Argument Property Direction

Can select "Property" to indicate the argument is not currently in use

UI Automation Activities

Containers - These are activities that identify the browsers or apps the process needs to interact with. All activities included within a Container will execute on the same application. Some examples are Open Browser, Attach Browser, Open Application, or Use Application/Browser. Input Activities - These activities send input to UI elements. They can be used to click, check, type into, send hotkeys, and so on. Output Activities - These activities get information from GUI Elements. They can instruct the Robot to get the text by using various methods, get structured data or get UiElements containing images. Synchronization Activities - They help you create triggers based on UI behavior, thus enabling the Robot to execute certain actions when specific events occur on a machine.

UI Frameworks

Default- This is the proprietary method which usually works correctly with all types of user interfaces. Active Accessibility- This represents an earlier solution from Microsoft that makes apps accessible. It is recommended when using legacy software, if the default framework does not work as expected. UI Automation- This is the improved accessibility model from Microsoft, which is recommended when using newer applications in case the default framework does not work as expected.

Dictionaries

Dictionaries (or Dictionary<TKey, TValue>, as you will encounter them) are collections of (key, value) pairs, in which the keys are unique. Think of the Address Book in your mobile phone, where each name has corresponding data (phone number(s), email). The data types for both keys and values have to be chosen when the variable is declared. Data types in Dictionaries can be any of the supported variables (including Dictionaries, for example). The operations that are most often associated with Dictionaries are: Adding and deleting (key, value) pairs. Retrieving the value associated with a key. Re-assigning new values to existing keys.

RPA Robots Can...

Extract structured data from documents, Log into and run applications, Open emails and attachments, Fill in forms, Read and write to databases, Make calculations, Connect to other systems Etc.

Libraries

Extracting workflows and reusing them across an automation project is a good habit for keeping a project organized, readable, and sustainable. At the same time, there are cases in which workflows can be reused in different projects. Consider the sequence of logging into SAP. Every time an automation project deals with SAP, the same sequence of steps will be needed. Storing and reusing components in separate projects is done through process libraries. A process library is a package that contains multiple reusable components, which consist of one or more workflows that act as individual activities. Libraries are saved as .nupkg files, and then installed in different projects using the Package Manager. How do we identify if a part of a project is a reusable? Consider what sequences of activities can be used in several processes. For example: login, logout, starting multiple applications common to several processes, data entry sequences. In libraries, each workflow can be set as public or private. Public items can be used as activities in projects where the libraries are added, while the private ones can be used only inside the libraries.

Fine-Tuning

Fine-tuning is the process of refining selectors in order to have the workflow correctly executed in situations in which the generated selector is unreliable, too specific or too sensitive with regards to system changes. It mainly consists of small simple changes that have a larger impact on the overall process, such as adding wildcards, using the repair function or using variables in selectors. Dynamically generated selectors - As it happens with some websites, the values of the attributes change with each visit. bullet Selectors being too specific - Some selectors are automatically generated with the name of the file or with a value that changes. Here, placeholders are very useful. bullet System changes - Some selectors contain the version of the application or another element that changes when the application is updated. bullet Selectors using IDX - The IDX is the index of the current element in a container with multiple similar elements. This might change when a new element appears in the same container. Using wildcards Wildcards are symbols that enable you to replace zero or multiple characters in a string. These are useful when dealing with dynamically-changing attributes in a selector. Asterisk (*) - replaces zero or more characters Question mark (?) - replaces a single character Using variables Variables are used as a property for the attribute of your target tag. This allows selectors to easily identify a target element based on the value of the variable or argument, and not an exact string, which might change. The variable can be changed to interact with a different element, without changing the selector itself. Using index variables Index variables are used to access UI elements based on their numerical position in the list or to access specific UI elements in an array or structure. They work by identifying the attributes of the UI elements which are numeric values that are consecutive. When data is stored in a list structure and you want to refer to them based on their position or numeric value, we use Index Variables. They are stored in defined variable with specific numeric value. For example:webctrl tableCol='6' tag='TD'tableRow='{{int_Index}}'/>

RPA Project Manager -

Forms and manages the RPA team, does resource planning and teams availability, in order to hit automation goals. Most of the times the PM is the Single Point of Contact (SPOC) for questions, RPA initiatives, or parallel RPA product projects.

Creating Arguments

From expressions (directly in an activity input field or expression editor. Select a part of the expression and press Ctrl+M (for In arguments) or Ctrl+Shift+M (for Out arguments). The Set Arg field is displayed.) From properties panel (In the Properties panel of any activity, right-click a field that can be edited, and select Create In Argument or Create Out Argument from the context menu. Alternatively, press Ctrl+M (In) or Ctrl+Shift+M (Out). The Set Arg field is displayed.) Arguments Panel (Navigate to the Arguments panel. Select the Create Argument line, and fill in the name, direction and type. A new argument is created.)

Full/Partial Selectors

Full: Contain all the tags and attributes needed to identify a UI element, including the top-level window; Generated by the Basic Recorder; Best suited when the actions performed require switching between multiple windows. Partial Selectors:Don't contain the tags and attributes of the top-level window, thus the activities with partial selectors must be enclosed in containers; Generated by the Desktop Recorder; Best suited for performing multiple actions in the same window. The best example of using a partial selector would be a simple automation where the deployed workflow only performs actions in the same application without shifting through multiple windows, like a simple CRM. On the other hand if the workflow would actually be required to interact with multiple windows, like the CRM in the example above and a document. This would make the UI elements dispersed in multiple windows, so full selectors would be required.

Version Control Systems

Git With the Git integration you can: Clone a remote repository. Add a project. Commit and push. Copy a project to Git. Create and manage branches. Solve conflicts with File Diff option. TFS The following versions are supported:201220132015Express 2012Express 2013Express 2015 First, you need to setup TFS in Studio. Then you can open a project or add a new project to the TFS. SVN With the SVN integration you can: Open a project from SVN. Add a project to SVN.

If Statement

In UiPath, the If statement is comprised from the elements you would expect it to be: 1. The Condition that is verified (with 2 potential outcomes - true or false). 2. The Then branch - the set of actions to be executed when the condition is true. 3. The Else branch - the set of actions to be executed when the condition is false. What is different is that, based on the chosen type of layout, there are 2 corresponding activities that fulfill the If statement role: The If activity in sequences. The Flow Decision activity in flowcharts. Moreover, the VB.Net If operator can be used inside expressions.

Sequences Vs. Flowcharts

In sequences, the process steps flow in a clear succession. Decision trees are rarely used. Activities in sequences are easier to read and maintain, thus they are highly recommended for simple, linear workflows. In flowcharts, the individual activities are a bit more difficult to read and edit, but the flows between them are much clearer. Use flowcharts when decision points and branching are needed in order to accommodate complex scenarios and decision mechanisms.

Automation First Mindset

In the Automation First Era, you need to constantly look at your work and the processes in your company through the lens of automation potential. This is what we call the Automation First mindset. A robot for every person, open and free collaboration, robots learn skills

Join Type for DataTables

Inner: Keep all rows from both tables that meet the Join rule. Any rows that do not meet the rule are removed from the resulting table. Left: Keep all rows from DataTable1 and only the values from DataTable2 which meet the Join rule. Null values are inserted into the column for the rows from DataTable1 that don't have a match in the DataTable2 rows. Full: Keep all rows from DataTable1 and DataTable2, regardless of whether the join condition is met. Null values are added into the rows from both tables that don't have a match.

RPA Solution Architect -

Is in charge of defining the Architecture of the RPA solution. The Solution Architect translates the requirements captured by the functional analysts, creating the architecture and design artifacts. They lead, advises, and is responsible for the developers' team delivery.

RPA Business Analyst -

Is responsible for mapping of the AS IS and proposed TO BE processes. Business Analysts hold knowledge of the business process that gets automated, general business process theory and RPA capabilities. They are responsible with listing the process requirements for automation, clarifying the inputs and expected outputs, creating RPA documentation (Process Design Documents, Process maps.

Business Process Owner -

Is the key stakeholder and beneficiaries of the RPA solution. Usually Senior Management level, with some 10-15+ years of experience, possibly split across domains. Multiple people can have this role, based on department (Finance, IT, HR, etc).

Do While

It executes a specific sequence while a condition is met. The condition is evaluated after each execution of the statements. For example, a robot could perform a refresh command on a website and then check if a relevant element was loaded. It will continue the refresh - check cycle until the element is loaded. The key difference between Do While and While is that for Do While, the activities contained within it are executed at least once.

While

It executes a specific sequence while a condition is met. The condition is evaluated before each execution of the statements. For example, if a Robot would play Blackjack, it should calculate the hand before deciding whether to draw another card.

Switch

It is a type of control flow statement that executes a set of activities out of multiple, based on the value of a specific expression.In other words, we use it instead of an If statement when we need at least 3 potential courses of action.This is done through the condition, which is not Boolean like in the case of If statement, but multiple.

Control Flow

It is the order in which activities are executed or evaluated in a software project. There are 4 predefined workflow layouts - Sequence, Flowchart, State Machine and Global Exception Handler.

Tenants & Folders

Just like folders, tenants are meant to replicate organizational hierarchies within the same instance of Orchestrator. From a hierarchy perspective, folders are subdivisions of tenants. And while in the folders case it's more about hierarchization and separation, tenants are clearly isolated from one another. Consider a typical large company, in which both the data and the business processes are typically separated between divisions like Sales and Finance. But then, the subdivisions would have some of the data or some of the processes separated, at the same time sharing others. In Orchestrator, some of the entities exist in the tenant context, while others exist in the folder context:

Dictionary Methods

Just like in the example of Lists, Dictionary variables need to be initialized with instantiated objects. In the previous example, the instantiation and initialization were done inside an 'Assign' activity. However, as you may remember from the Lists chapter, they can also be done from the Variables panel. VarName.Add(Key, Value) - adds an item to an existing Dictionary. Because Add does not return a value, we use the Invoke Method activity. VarName.Remove(Key) - removes an item from the Dictionary. It can be used in an 'Assign' activity. VarName.Item(Key) - returns the Dictionary item by its key VarName.Count - returns an Int32 value of the number of Dictionary items VarName.ContainsKey(Key) - checks if the item with the given key exists in the Dictionary and returns a Boolean result VarName.TryGetValue(Key, Value) - checks if an item with a given key exists in the Dictionary and returns a Boolean result and the value if found

Lists

Lists (or List<T>, as you will encounter them) are data structures consisting of objects of the same data type (for example string or integer). Each object has a fixed position in the list; thus, it can be accessed by index. While arrays are fixed-size structures for storing multiple objects, lists allow us to add, insert and remove items. Lists can store large numbers of elements - names, numbers, time coordinates and many others. Lists provide specific methods of manipulation, such as: Adding and removing items. Searching for an element. Looping through the items (and performing certain actions on each). Sorting the objects. Extracting items and converting them to other data types.

Loops

Loops are repetitions of a set of operations based on a given condition. In UiPath, the most important loops are: Do While, While and For Each.

RegEx Methods

Matches: Searches an input string for all occurrences and returns all the successful matches. Output datatype: System.Collections.Generic.IEnumerable<System.Text.RegularExpressions.Match> IsMatch: Indicates whether the specified regular expression finds a match in the specified input string. Output datatype: Boolean Replace: Replaces strings that match a regular expression pattern with a specified replacement string. Output datatype: String

Variables Panel / Properties

Name: as descriptive as possible, "PascalCase" Type: what type of data can be stored Default Value: some variables have initial values that can change, if no value is assigned when declared, there is a default rule that assigns a value Scope: the part of the workflow the variable can be used. global (used throughout entire workflow) or local (in activity)... don't make things unnecessarily global ***Scope Note: In UiPath, the scope of a variable cannot exceed the workflow in which it was defined. Since business automation projects rarely consist of single workflows, we need a different kind of vehicle to pass data between workflows, and this is called an argument.

RPA Developer -

On complex projects, several developers will collaborate to automate all processes.

Orchestrator - What is it?

Orchestrator is the component of the UiPath Platform for managing automations, robots and the related entities. Although having different cloud and on-premises deployment options and a rather complex infrastructure consisting of nodes, servers and high-availability capabilities, the users access it through a simple web interface. Orchestrator offers role-based access control and a structure of tenants and folders to replicate organizational structures. Users are able to run the automation workflows developed in Studio and published to Orchestrator using the unattended robot workforce. Furthermore, Orchestrator is used to manage and distribute licenses, as well as for storing automation resources.

UiPath Orchestrator

Orchestrator, the heart of automation management, is a web application that allows managing, controlling, and monitoring the robots and the automations. With Orchestrator we can deploy, trigger, measure, provision, track, and ensure the security of every robot in the organization. Orchestrator also functions as a repository for libraries, reusable components, assets, and processes used by robots or by developers.

Exception Handling

Predicting and treating exceptions can be done in two ways: bullet At activity level, using Try/Catch blocks or Retry Scope. bullet At a global level, using the Global Exception Handler.

Automation Potential of a Project

Process fitness & automation complexity Process Fitness: Rule based, repetitive process and/or automatable, standard input (easily readable), stable (no changes expected in the next months) Automation Complexity: # of screens, application type, business logic scenarios, types and number of inputs

Activity Properties

PropertyWhat it does DelayAfter/DelayBefore- How many milliseconds the Robot waits before or after executing the activity. ContinueOnError-Will an exception encountered while executing the activity be thrown or ignored. For example, if the element is not found, will the Robot throw an error and stop the execution, or will it ignore and continue?) Target-Provides several properties related to identifying the target UI Element. Timeout (milliseconds)-How many milliseconds will the Robot try to perform an action on an UI element. SendWindowsMessages/Simulate Type-What input method do we use for input activities. Output-It Stores the output of the activity in the form of variables.

Orchestrator Capabilities & More

Provisioning: Creates and maintains the connection with robots and attended users. bullet Control and license distribution: Enables the creation, assignment and maintenance of licenses, roles, permissions, groups, and folder hierarchies. bullet Running automation jobs in unattended mode: Enables the creation and distribution of automation jobs in various ways, including through queues and triggers. bullet Automation storage and distribution: Allows the controlled storage and distribution of automation projects, assets, and credentials, as well as large files used in automations. bullet Monitoring: Allows monitoring of jobs and robots and stores logs for auditing and analytics. bullet Inter-connectivity: Acts as the centralized point of communication for third-party solutions or applications.

Orchestrator Capabilities

Provisioning: Creates and maintains the connection with robots. Control and license distribution: Enables the creation, assignment and maintenance of licenses, roles, permissions, groups, and folder hierarchies. Automation storage and distribution: Allows the controlled storage and distribution of automation projects, assets, and credentials, as well as large files used in automations. Running automation jobs in unattended mode: Enables the creation and distribution of automation jobs in various ways, including through queues and triggers. Monitoring: Allows monitoring of jobs and robots and stores logs for auditing and analytics.

RPA primarily targets processes...

RPA primarily targets processes that are highly manual, repetitive, rule-based, and have a low exception rate and a standard electronic readable input.

Recorders

Recording is an important part of UiPath Studio, that can help you save a lot of time when automating your business processes. This functionality enables you to easily capture a user's actions on the screen and translates them into sequences. These projects can be modified and parameterized so that you can easily replay and reuse them in as many other processes as you need.

RegEx

Regular Expression (REGEX, or regexp) is a specific search pattern that can be used to easily match, locate and manage text. However, creating RegEx expressions may be challenging. UiPath Studio contains a RegEx builder that simplifies the creation of regular expressions. Typical uses of RegEx include: Input validation. String parsing. Data scraping. String manipulation.

Targeting Methods - subset of properties

Selectors *most common Fuzzy Selectors Image Anchors

Workflow Layout

Sequence/Flowchart/State Machine Sequnce: - When to use it? When there's clear succession of steps, without too many conditions (for example, a UI automation). Usually, sequences are used to nest workflows and the high-level logic is handled through flowcharts or state machines. What are the advantages? Easy to understand and follow, having a top to bottom approach. Great for simple logic, like searching for an item on the internet. What are the disadvantages? Nesting too many conditions in the same sequence makes the process hard to read. Not suitable for continuous flows. Flowchart - When to use it? When you have a complex flow with several conditions, a flowchart is at least visually much easier to understand and follow. When you need a flow that terminates only in one of several conditions. What are the advantages? Easy to understand, as it is similar to logic diagrams in software computing. The most important aspect of flowcharts is that, unlike sequences, they present multiple branching logical operators, that enable you to create complex business processes and connect activities in multiple ways. What are the disadvantages? Flowcharts should be used only as the general workflow (with sequences nested inside), not for individual parts of projects (nested inside other workflows). State Machine - When to use it? First of all, let's understand what a state machine is. It is an abstract machine consisting of a finite number of pre-defined states and transitions between these states. At any point, based on the external inputs and conditions verified, it can be in only one of the states. State machines can be used with a finite number of clear and stable states to go through. Some examples from your daily life include vending machines, elevators or traffic lights. What are the advantages? Can be used for continuous workflows that are more complex. Transitions between states can be easily defined and offer flexibility. Can accommodate processes that are more complex and cannot be captured by simple loops and If statements. It is easier to cover all the possible cases/transitions with state machines. What are the disadvantages? Longer development time due to their complexity: splitting the process into logical "states", figuring out transitions, and so on. Note: State machines are not to be overused - they should define only the skeleton of the project. In fact, there are templates built upon state machines especially designed to build large enterprise automations. The most commonly used is the Robotic Enterprise Framework - we have a separate course to cover it in the RPA Developer Advanced learning plan.

Handling data in projects with multiple workflows

Splitting a project into smaller workflows has an influence on how data is handled. Since variables work only inside the same workflow, having more than one workflow requires arguments. As you probably know from the Variables, Data Types, and Control Flow in Studio course, Arguments are very similar to variables - they store data dynamically, they have the same data types, and they support the same methods. The main difference is the 'Direction' property, signifying the direction from/to which the data is passed. The direction can be In, Out and In/Out: bullet In - if we want to pass a value to be used only inside the invoked workflow. bullet Out - if we want to pass a value to be used outside of the invoked workflow, in the parent workflow. bullet In/Out - if we want to pass a value from the parent workflow to the invoked workflow, modify it in the invoked workflow and then pass the new value back to the parent workflow. Consider an invoked workflow that subtracts all the taxes from a gross salary. You will need at least 2 arguments: An 'in' argument mapped to the variable containing the gross salary An 'out' argument to pass the value of the net salary to a variable in the parent workflow Note: When the 'Extract as Workflow' action is used, variables are automatically turned into arguments. Best practices on using arguments Naming: Use the direction as a prefix when naming arguments - e.g. in_ArgumentName1, out_ArgumentName2, io_ArgumentName3. Directions: Be specific with argument directions. Avoid using In/Out unless you need to.

String Methods

String.Concat - Concatenates the string representations of two specified objects.Expression: String.Concat (VarName1, VarName2) Output datatype: String Contains - Checks whether a specified substring occurs within a string. Returns true or false.Expression: VarName.Contains ("text") Output datatype: Boolean String.Format - Converts the value of objects to strings (and inserts them into another text).Expression: String.Format("{0} is {1}", VarName1, VarName2) Output datatype: String IndexOf - Returns the zero-based index of the first occurrence of a specified Unicode character or string within this instance.Expression: VarName1.IndexOf("a") Output datatype: Int32 LastIndexOf - Reports the zero-based index position of the last occurrence of a specified Unicode character or string within this instance. Expression: VarName1.LastIndexOf("author") Output datatype: Int32 String.Join - Concatenates the elements in a collection and displays them as String.Expression: String.Join("|", CollVarName1) Output datatype: String Replace - Replaces all the occurrences of a substring in a string.Expression: VarName.Replace ("original", "replaced") Output datatype: String Split - Splits a string into substrings using a given separator.Expression: VarName.Split("|"c)(index) Output datatype: Array of String Substring - Extracts a substring from a string using the starting index and the length.Expression: VarName1.Substring(startIndex, length) Output datatype: String

AI Computer Vision

The AI Computer Vision activity package contains refactored fundamental UI automation activities such as Click, Type Into, or Get Text. The main difference between the CV activities and their counterparts is their usage of the Computer Vision neural network developed in-house by our Machine Learning team. The neural network is able to identify UI elements such as buttons, text input fields, or check boxes without the use of selectors. This is an advanced feature we will learn more about later.

Application Exception

The Application Exception describes an error rooted in a technical issue, such as an application that is not responding. Consider a project extracting phone numbers from an employee database and inserting them into a financial application. If, when the transaction is attempted, the financial application freezes, the Robot cannot find the field where it should insert the phone number, and eventually throws an error. These kinds of issues have a chance of being solved simply by retrying the transaction, as the application can unfreeze. In managing application exceptions, it is extremely important to have good naming conventions for activities and workflows. This will help with tracking the activity that caused the exception.

Business Rule Exception

The Business Exception describes an error rooted in the fact that certain data which the automation project depends on is incomplete, missing, outside of set boundaries (like trying to extract more from the ATM than the daily limit) or does not pass other data validation criteria (like an invoice amount containing letters). Business Rule Exceptions do not occur "naturally", they need to be defined using a Throw activity. Consider a robot that processes invoices, with a business rule set by the process owner that only invoices with the amount below 1 000$ must enter the automated process. For the others, a different flow is applicable, involving a human user to process them. In this case, retrying the transaction does not yield any chance of solving the issue, instead the business user should be notified about the pending invoice and the case should be treated as a business exception - because is an exception from the usual process flow and the validation is made explicitly by the developer inside the workflow. As a recommended practice, the text in the exception should contain enough information for a human user (business user or developer) to understand what happened and what actions need to be taken.

Property Explorer

The Property Explorer is a functionality of the UI Explorer that displays all the attributes of a certain UI element, including those that are not displayed in the selector, like position, visibility, innertext, and so on. What are some business scenarios in which I will use the Property Explorer? When you want to start an activity after a certain attribute changed its value (using the Wait Attribute activity). When you want to change the value of an attribute on a webpage, like its visibility (using the Set Attribute activity). When you want to check the state of a certain UI element by checking on an attribute (using the Get Attribute activity).

Robot

The Robot is UiPath's execution agent installed on a machine and enabling you to run automation jobs based on processes developed in Studio.

Studio Family

The Studio family consists of three profiles available in the same application. While no additional installation is needed, accessing the profiles depends on the license: StudioX - the Citizen Developer profile Studio - the RPA Developer profile Studio Pro - the Advanced Developer profile, with access to testing capabilities, as well as C# support The licenses are incremental, meaning that a Studio license will offer access to StudioX. All these licenses typically include an attended robot and UiPath Assistant.

UI Explorer

The UI Explorer is the functionality in UiPath Studio that allows you to analyze and edit selectors. It contains a status button showing users the state of the selector, a visual tree panel that displays a navigable UI of each application running at that moment, as well as the selected UI element. The UI Explorer displays all the available tags and attributes and gives you the option to check them in or out.

Exiting Loops

The While and Do While loops will exit when upon checking, the condition is no longer true. bullet The For Each loop will exit when it has finished processing every item in the input collection. bullet The Break activity enables you to exit the current loop activity (e.g. For Each, While, or Do While) at a chosen point and continues the workflow with the activity that follows it.

Arrays

The array is a data type that enables storing multiple values of the same variable or argument. Think of it as a group of elements with a size that is defined at creation, and where each item can be identified by its index. In UiPath Studio, you can create arrays of numbers, of strings, of Boolean values and so on. As a good case practice, arrays are used for defined sets of data (for example, the months of the year or a predefined list of files in a folder). Whenever the collection might require size changes, a List is probably the better option.

Automation Cloud

The cloud platform of UiPath, the single place for managing users and services, such as cloud Orchestrator, cloud AI Fabric, cloud Data Service, and so on.

Studio

The component of the UiPath RPA Platform for developing Robotic Process Automation projects

Orchestrator

The component of the UiPath RPA Platform in charge of the management of automations, users and robots, as well as the management of the assets used in development or in running automations.

Assistant

The interface between the human user and the attended robot. It allows the human to trigger jobs, but also to organize processes, add reminders and so on.

Ui Automation

The key concepts of UI Automation in UiPath are: UI Automation Activities, Activity Properties, Targeting Methods, Input and Output Methods, Recorders, The Object Repository and Computer vision. UI Automation Activities - Activities can be containers, input activities, output activities or synchronization activities. Activity Properties - Properties determine how the Robot performs an action. They can be found in the Properties panel. Targeting Methods - They provide several ways to identify the UI element the Robot will be interacting with. By far the most common are selectors. Input and Output Methods - Define the type of technology used in interacting with UI elements. The technology used by Input methods is different than the one used in Ouput methods. Recorders - This functionality enables you to easily capture a user's actions on the screen and translates them into sequences. The Object Repository - The Object Repository ensures the management, reusability, and reliability of UI elements by capturing them as objects in a repository, sharable across projects. AI Computer Vision - Is able to identify UI elements such as buttons, text input fields, or check boxes without the use of selectors.

Object Repository

The object repository ensures the management, reusability, and reliability of UI elements by capturing them as objects in a repository, sharable across projects. It allows for creating and reusing UI taxonomies inside and across automation projects. This is a more advanced feature we will learn more about later.

Modern vs. Classic Design

There are two UI Automation design experiences in UiPath Studio: modern and classic. The default experience is classic. This can be changed at project level or for all new projects. The two experiences differ on: Activities: Both experiences provide different activities, but you can filter the Activities pane to see the ones from the non-default experience.Activity properties: The properties are slightly different between the Modern and Classic activities.Targeting methods: Classic uses mostly selectors, while modern uses Unified Target (a stack of Selector, Fuzzy Selector, Anchor and Image).Recorders: Modern offers a simplified recording solution with two recorders, while classic offers six recorders.Scraping wizards: Modern offers the Table Extraction wizard while classic offers the Data Scraping and Screen Scraping wizards.Object repository: The object repository is only available to the modern design experience.

Reference Type Initialization

To initialize a variable is to specify an initial value to assign to it. All variables are given an initial value when they are declared. However, this process is a bit different depending on whether the new variables are of the value or reference type. bullet Value type - For numeric, Boolean, DateTime and other value types, the compiler will give them a valid value if we do not explicitly do so. For example, Ints initialize to zero by default, DateTimes initialize to DateTime.MinValue by default. In Studio, Strings are also assigned a blank default value, even though they are of the reference type. bullet Reference type - Reference type variables, like Lists and Dictionaries, initialize to the object we provide. The compiler will not assign a value if we don't. This means we need to instantiate an object and assign it to the variable we've just declared. We declare a reference variable, say a List of type String. We provide the name, select the type System.Collections.Generic.List<T> and indicate String. We instantiate an object to be assigned as the initial value for the variable. In our case, we want to start with a List of String object which does not contain values, so we use the expression new List(of String). We assign the object to the new variable (or initialize the variable) either by using the Default value in the Variables panel or by using an Assign activity.

DateTime Methods

ToString: - Converts variables to string formats. Data can be further manipulated to specific types of strings as well. DateTime.Parse: - Converts variables from string to DateTime variables. This method only works with Invariant culture time formatting variations. Subtract: - Performs a subtract operation on a DateTime variable unit value. Units can vary from days to milliseconds. Math.Abs: - Is used to display an absolute value.For example, our result is "-5" but we want the result to be displayed as "5".During processing, we cannot utilize dates with negative numbers which can result from different DateTime operations.

T/F Arrays can be modified

True! Assign --> StringArray(0) = "Changed to This"

UiPath Assistant

UiPath Assistant is the component that provides a friendly interface to interact with attended robots. It is the tool that we use to easily access, manage, and run automations.

GenericValue

UiPath.Core.GenericValue Please note that the first element in your expression is used as a guideline for what operation Studio performs. For example, when you try to add two GenericValue variables, if the first one in the expression is defined as a String, the result is the concatenation of the two. Please remember that GenericValue variables are a temporary solution at most. When it becomes clear what the data type should be, we strongly recommend that you change it to the specific type

Variables

Variables are containers that can hold multiple data entries (values) of the same data type. The value of a variable can change through external input, data manipulation or passing from one activity to another. Variables help us pass data from one activity to another.

Parallel (activity)

What is it? The Parallel activity enables you to execute two or more child activity branches at the same time. In UiPath Studio, the Parallel activity can be found in the Activities panel, under Workflow > Control > Parallel. The Parallel activity finishes only after all child activities are complete or when its CompletionCondition property evaluates to true. The Parallel activity is very beneficial when there are one or more blocking activities in the branches, because it executes all child activities simultaneously and asynchronously, thus saving time and being very efficient.

RPA Infrastructure Engineer -

With good technical and security skills, they are responsible for setting up and maintaining hardware and software resources for UiPath product installations. They set up accounts for all the developers, end users and robots.

RPA

technology that enables software 'robots' to carry out repetitive, rule-based digital tasks

Creating Variables

variables panel (create variable option), Expressions from activity Ctrl + K (ex. in an assign activity, Set Var field is displayed), activity properties panel Ctrl + K in an input field that accepts variables (Set Var field is displayed)