ssIs RPA the only technology available for Business Process automation?

No. Today, multiple technologies revolve around RPA to enhance the automation results.

If RPA can process only structured digital documents, together with AI and ML models it can process, for
example, scanned invoices - which are unstructured, digitally converted documents. 

Where RPA can only interact with an application through the User Interface, with Native Integrations,
the automation development is much simpler for commonly used applications like SAP or Salesforce.

Advanced analytics help you measure the automation performance against business KPIs, like time or
money saved.

Long-running workflows enable you to orchestrate complex automated processes that facilitate

synchronous and asynchronous interactions between human users and robots for maximum
effectiveness and resource allocation.

Process mining and task mining allow you to scientifically discover automation use-cases in the
organization by analyzing back-end and front-end data.

Automation is industry agnostic - no matter how you look at it, there are automation use-cases in any
business.

Automation doesn't just impact revenue and time - automating repetitive tasks also leads to an
improved customer and employee experience, eases the AI operations, ensures compliance, and makes
the decision-making process faster.

UiPath Studio is a tool for building automation processes. The Robot executes the processes built in
Studio published to Orchestrator or locally. UiPath Orchestrator is a web application that acts as the
interface between Studio and Robot and manages, controls, and monitors automation tasks. 

Let’s see how the core components work together.

RPA Developers build automation projects using the Studio family, to fulfil an automation need. These
automation projects can then be published as NuGet packages either locally or in Orchestrator.
Automation projects published to Orchestrator are stored as packages, along with their versions. If an
updated version of a project is available, it is stored as a separate package in Orchestrator. To run
automation projects, published packages need to be associated with folders. When a published package
is paired with a folder, it becomes a process and can be run by robots with access to the folder. 
Human users can trigger robots, through the UiPath Assistant tool to execute processes on their
machines. We call these robots attended robots. The robots deployed on separate machines, working
without direct human intervention, are called Unattended Robots. Process execution for this type of
robots is initiated and managed from Orchestrator. In both cases, process execution is done through
jobs. 
Be it attended or unattended, communication between Robots and the Orchestrator is always triggered
by the Robot. This is done by the Robot Service component of the Robot through a heartbeat
mechanism. Every 30 seconds, the Robot Service sends a heartbeat to the Orchestrator and waits for the
Orchestrator to respond. When there is a job to be done, the Orchestrator responds to the heartbeat by
passing the job info to the robot.  
In cases where there are multiple Orchestrators involved in the architecture, the packages that the
robots need to execute jobs are kept in an external storage location. When a robot runs a job for the
first time, it will not have the workflow available locally. The robot then requests the workflow from
Orchestrator, which then goes to the storage location, retrieves the correct workflow, and passes it to
the robot. In such cases, even when a Studio user publishes a package, the Orchestrator moves the
package to the storage location, which is retrieved when required. The robot then runs the process. 

UiPath Studio
UiPath Studio is an integrated development environment for RPA developers to design,develop, and
debug automation projects. Studio connects with Orchestrator to publish automated processes as
NuGet packages to feeds. From there, they are distributed to robots to be executed. 

When we say Studio, we could talk about three profiles: Studio, StudioX, and Studio Pro. These are
meant to match different coding skills that developers may have:

 StudioX is meant for business users looking to automate tasks for themselves and
their immediate teams. 

Studio is meant for RPA developers looking to build complex unattended or

attended process automations.   
Studio Pro is meant for more advanced developers. This more advanced IDE
contains test automation tools, RPA testing, and advanced coding services.  
 
Depending on the type of Studio license an enterprise may purchase, Studio users can switch between
Studio, StudioX, and Studio Pro profiles as they need. 

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.

There are two types of UiPath robots and they differ both in the way they work and in the way they are
licensed:

Attended robots

They are digital helpers for human users. They work on the same machines as 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. For example, opening an application or receiving an email. 

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. 

Unattended robots
These are meant to work non-stop, with as little input from human users as possible. They are deployed
on separate machines and their jobs are triggered exclusively from Orchestrator.

Their interactions with human users are typically handled with as little disruption as possible, by creating
and sending requests for human input or validation as tasks. While these await to be processed,
unattended robots can continue their work by picking up other jobs. When human input is finally
provided, unattended robots can resume their work on the process.

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.

The main capabilities of Orchestrator:

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.

 As an RPA Developer, you will use the Studio family (Studio, StudioX, and Studio Pro) to build
reliable automation processes based on business requirements. 
 Studio, Robots, and Orchestrator communicate with one another in different phases.
 Automation projects built in Studio are published locally or through Orchestrator.
 Published automation projects are called packages.
 Attended robots work on the same machine as the human users.
 In attended scenarios, processes are typically started by human users from UiPath Assistant.
 Unattended robots are deployed on separate machines, which are not used by human users
(often virtual machines).
 In unattended scenarios, process execution is started, scheduled and managed from
Orchestrator.
Hello and Welcome to “UiPath First Run Experience”! 
In this demo we will navigate the end to end experience of setting up, building and running our first
automation in attended mode. More specifically, we’ll get access to UiPath Automation Cloud, download
the installer, sign in with Studio, build a Hello World project, publish it in Orchestrator and run in with
our Assistant. Seems a lot? You’re about to see that it’s not. Let`s get started! 
We’ll start the demo with the assumption that you already have an Automation Cloud account, and you
are logged in either with an community or with an enterprise license as an admin. If you don’t have an
account yet, you can create your own by visiting UiPath.com and clicking Try UiPath Free. You will be
directed to the Automation Cloud signup page, from where it will be easy to create your account and
become its administrator. 
Now, as an administrator, you will have permissions to add, modify and delete user accounts in
Automation Cloud. 
So, let’s add a new user. To do that, click on the admin tab on the left ribbon. 
Here’s where we can see the tenants, the users and groups, as well as the licenses. On the Community
plan you’ll only have one tenant, but in Enterprise, you may have several. But now, we’ll click User and
Groups and Invite User. 
In the invite user panel, we will enter the new user email address and assign a group membership.  
Now our user has been added to the Automation Cloud instance, but that doesn’t mean they have
access to all the actual services. For this, we’ll have to navigate to the individual services, assign roles
and licenses and refine permissions. So, let’s go to Orchestrator, directly to Manage users. 
We’re now in the Orchestrator tenant, where we’ll click Add User, search for our user and grant them
the Automation User role at the tenant level.  
This gives the user permissions to execute processes. There are several other options here, like allowing
the web login and the interface available for the user, but let’s continue with our process now. 
Next, let’s enable the robot creation and select the license type. Before doing so, you need to ensure
you have the right licenses to allocate. Notice that we haven’t filled in the domain and username. This is
because we’ll be using the interactive sign in feature. If you won’t be using that, you’ll need to fill in here
these details. 
Great! We have successfully added a new user and provisioned an attended license. It’s time to switch
from admin to the user perspective and see how we can continue there. 
As soon as the administrator has added my user, I get an automatically generated email with the access
link. We’ll select our account or enter the credentials – and we’re in! 
It’s time to install Studio. 
We can do that by clicking Download Studio/StudioX or by navigating to the Resource Center located on
the left side ribbon. 
Here, we have several versions of the Studio installer to choose between: the Enterprise edition or a
couple different Community Edition versions. 
In this demo, we’ll download the latest version of Community Edition. Once the download is finalized
and we click on the downloaded file, the installation will go automatically. And as soon as it’s done, we’ll
be prompted to sign in. 
Here’s where we’ll input the Automation Cloud address from the browser. This will open the browser
with Automation Cloud and finalize the sign in. If we have access to several Automation Cloud tenants,
we’ll be able to select between them. In this case, we have access to a single tenant, so Studio will
open. 
On this splash screen, we’re able to choose between several resources to know more about StudioX. 
As you probably know, there are three profiles in Studio, depending on your technical knowledge. This
right here is StudioX, targeted at Citizen Developers. Depending on the type of license, you can switch to
other profiles by navigating to Settings, under License and Profile. 
Alright! It’s time to create a project in StudioX.  
We’ll choose blank task and give it a name - let's say HelloWorld. 
We’ll then add a single message box activity, type HelloWorld and save. 
Now let’s publish the project. 
And because we’ve signed into our Orchestrator, the project published will appear in  UiPath Assistant,
from where we can directly run it. We’ll just hit the start button. And here it is! 
This concludes our First Run Experience in attended mode. It’s rather easy when all the components are
connected. 

Steps to set up your attended user and run your first job
As the Automation Cloud account admin:

1. Invite the new user in Automation Cloud and include them in the Automation Developers group
As an attended user:
1. Login to Automation Cloud
2. Go to Resources and download Studio installer
3. Run the Studio installer
4. Sign in to Automation Cloud from Studio
5. Choose the Studio profile
6. Create a new task automation in Studio
7. Add a Message Box and input the desired message
8. Publish the project to Orchestrator
9. Open UiPath Assistant and run a job for the newly added process

How does the scenario vary based on the license?

Larger enterprise customers may choose an on-premises deployment and the integration with
Active Directory. In this case, the user groups would be imported in the host tenant, where
licenses would also be allocated. From that point onwards, the steps in the video would
apply.For Community accounts, the first user would also be the admin on the Automation Cloud
and the Orchestrator service.

How are the attended licenses configured and allocated?

–

There are 4 attended user license types: Attended, StudioX, Studio and Studio Pro. They form a pyramid,
with the superior licenses (Studio Pro being the most powerful) offering access to the others.

The Automation Developers group is configured to automatically grant a license to the members.
Admins can change this from Orchestrator.

What's the relation between Automation Cloud and Orchestrator?

UiPath Automation Cloud is our cloud platform, hosting our cloud products and services.
Cloud Orchestrator is a service hosted in Automation Cloud. Users and groups need to be created first in
Automation Cloud. Then you'll be able to add them and configure their permissions and licenses in
Orchestrator. The Automation Users and Automation Developers groups are by default added in
Orchestrator.

What's the relation between Attended Robot and Assistant?

Right now, UiPath Assistant is an interface between the human user and the attended robot. It's the

default way used to run and customize jobs in attended mode.

Studio
–

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

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.

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

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.

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.

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.

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. 

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.

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

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.

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.

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

We envision a work world where “automation first” is the first thought when an employee needs help to
accomplish a task or improve a work process. The first question will be, “How can I automate this task to
improve my efficiency and effectiveness?”, rather than trying to execute all work manually. 

Adopting an “automation first” mindset is the first step on the path to making digital transformation real
in the enterprise. Thinking automation first enables your company to move faster and more effectively.
It helps you serve customers better. It enables you to operate more efficiently. It unburdens your
employees from mundane, repetitive work, allowing them to focus on solving problems and creating
value. 

The automation first three-pronged approach:

A Robot for Every Person
Just as Bill Gates envisioned a world with a PC for every desktop, UiPath envisions a world with a robot
for every person. When every person has a robot to help with mundane tasks, it frees them to use time
for higher-level work. 

Open and Free Collaboration

In business, cooperation and competition are deeply co-dependent. Technologies, too, can work
together, and can also work with people. Ideas can mix, mingle, and make magic. By facilitating these
unions, whether through our community, our partners or through a combination of both, UiPath creates
an environment to nurture automation first and to accelerate human achievement.

Robots Learn Skills

We’re enabling robots to learn new skills through AI and machine learning. To help humans, robots not
only must do the grunt work, but they need to be able to act intelligently.  With AI and machine
learning, robots can extend the scope of work they complete beyond rules-based-action to judgment
tasks. 

What is a Business Process?

The successful RPA developer combines a good grasp of the technical skill set with the ability to quickly
understand business processes in terms of inputs, outputs and decision points. The latter will come into
play when collaborating with an RPA Business Analyst on a large implementation project or when
undertaking a smaller project on your own. 

 Definition: A process is a set of interrelated or interacting activities that transforms

inputs into outputs.

Components of a process:

 Inputs - the data that goes in the process.

 Process Flows - the sequences of sub-processes or activities undertaken in
the process.
 Source Applications -  the applications or systems used to perform the sub-
processes or activities of the process.
 Outputs - the result generated by the process.
  Things to remember: The outputs of a process can serve as inputs for other
processes.

Organizations use processes because planning and executing them under controlled conditions can,
among other things, improve compliance, ensure that operational needs are met, help in managing risks
and drive improvement.

The relation between processes and procedures

There are a lot of things that are missing from the definition of a standard process, such as time
constraints, dependency on other processes, variations and how resources are assigned. This is where
procedures come into play. Essentially, a procedure complements a process and describes the way it is
carried out; it explains who is responsible for each part of the process, when each part of the process
needs to occur, how to handle exceptions and the specifications applicable to each part of the process. 

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

In what concerns the way they are documented, processes and procedures are different. A process is
typically documented via a diagram, be it a flowchart or workflow, which aims to highlight the logical
sequence of the process steps. A procedure, on the other hand, is often a complex, written document,
focused on providing guidelines.   
Process example: Order-to-Cash 

To better understand this, let's take a commonly automated business process and compare the manual
("As Is") flowchart with the automated ("To Be") flowchart.

1. A Purchase Order is received via email.

2. The agent opens the email attachment and checks that the product code is present
in the PO.
3. If the product code is present in the PO, the agent opens SAP and runs a specific
SAP transaction.
1. If the product code is not present in the PO, the agent looks it up in the
master data file.
2. If the product code is present in the master data file, the agent opens SAP
and runs a specific SAP transaction.
3. If the product code is not present in the master data file, the agent sends
out an email to the Master Data Analyst to update the file.
4. Once the product code is provided, the agent populates the required fields in the
SAP screen, as per the organization requirements and the PO .
5. Next, the agent generates the sales order.
 6. Finally, the agent replies to the initial email, adds the Sales Order in the attachment
and moves the email to the processed folder.

The "As-Is" process diagram 

 Inputs - The received Email message.

 Process Flows - the verification of the product code presence, the SAP transaction
execution and the SAP fields population.
 Source Applications -  Outlook, Desktop and SAP.
 Outputs - the result generated by the process.

Also, there are several sub-process outputs that serve as input for other sub-processes. For example, the
result of the missing product code in the master data file check represents an input for the master data
analyst to update the file. 

In the context of an RPA implementation, the process flow we have just described, along with the
procedure documenting it, would be considered the “As-Is” process.  
The "To-Be" process diagram

The “To-Be” process for our example factors in the potential of RPA. As we can see, most of the manual
steps of the process (previously colored in blue) can be automated through RPA.
What makes a process a good candidate for automation?

There are a number of factors you can take into account when considering if a process is fit for
automation. Normally the analysis and prioritization are performed by an RPA Business Analyst.
However, it's useful for developers to evaluate the prioritization and on smaller implementations, there
may not be a Business Analyst in the team. 

There are two sets of criteria you can use to determine the automation potential: process
fitness and automation complexity. 
Process fitness
Here are the criteria you can evaluate how fit a process is for automation:

Rule-based
–

The decisions made (including data interpretation) in the process can be captured in a pre-defined logic.
The exception rate is either low or can be included as well in the business logic.
Automatable and/or repetitive process
–

We can differentiate 4 types of processes:

 Manual and non-repetitive: the process steps are performed by humans and can be different
every time the process is executed.
  Manual and repetitive: the steps in the process are performed by the user, and at least some of
them are the same every time.
 Semi-automated & repetitive: some of the repetitive steps have already been automated (using
macros, Outlook rules, and so on).
 Automated: there are processes that have been already automated using other technologies
than RPA.

Processes that need to stay manual or are non-repetitive, due to the high exception rate or factors that
cannot be integrated in a business logic, aren't good candidates for automation.

Standard input
–

The input in the process should either be electronic and easily readable or readable using a technology
that can be associated with RPA (such as OCR). A good example is an invoice having the fields pre-
defined.

Stable
–

Processes that have been the same for a certain period of time and no changes are expected within the
next months are good candidates for automation, provided they meet the other criteria as well.

Automation complexity
This set of criteria determines how hard it is to automate a process:
Number of Screens
–

RPA works by programming the robot to perform tasks at screen level (when the screen changes, the
logic has to be taught). The higher the number of screens, the more elements have to be captured and
configured prior to the process automation.

Types of applications
–

Some applications are more easily automated (such as the Office suite or browsers), others heavily
increase the automation effort (Mainframe, for example). And the more different applications there are,
the number of screens will increase, as well (see previous point).

Business logic scenarios

–

An automation's complexity increases with the number of decision points in the business logic. Basically,
each one could multiply by two times the number of scenarios.
Types and number of inputs
–

As previously stated, standard input is desirable. Yet there are cases in which one standard input (such
as an invoice) has to be configured for each supplier that will be affected by the automation. Moreover,
non-standard input can be of different complexity grades, with free text being the most complex.

Assessing the automation potential

By using these factors in our automation potential assessment, we can sort processes into 4 categories:

NO RPA
Processes where change is frequent, the system environment is volatile, and multiple manual (even non-
digital) actions are required.

SEMI-AUTOMATION
Processes that can be broken down into steps that can be clearly automated, and steps that need to
stay manual (such as validations or usage of physical security tokens).

HIGH-COST RPA
Processes that are rather digital and can be automated, but use some technologies that are complex
(such as OCR) or require advanced programming skills.

ZERO-TOUCH AUTOMATION
Processes that are digital and involve a highly static system and process environment, so that they can
be easily broken into instructions and simple triggers can be defined.

How do RPA project implementations work?

Before getting into the specifics of developing workflows, it's helpful to understand the context you will
be working in, the stages of RPA implementations and who you will be working with. 

Most often, we will find six stages in RPA implementations:

 1

1 Prepare RPA - the processes are defined, assessed, prioritized and the implementation is
planned. 

 2 Solution Design - Each process to be automated is documented ("as is" and "to be"), the
architecture is created and reviewed, the test scenarios and environments are prepared and the
solution design is created and documented for each process.
 3
 3 Build RPA - The processes are automated, the workflow is tested and validated and the UAT
prepared.
 4
 4 Test RPA - The UAT is performed, the workflow is debugged and the process is signed off.

 5 Stabilize RPA - The Go-Live is prepared, the process is moved to production, monitored,
measured and the lessons learned are documented.

6 Constant Improvement - The process automation performance is assessed, the benefits

tracked and the changes managed.

What are variables?

Variables are containers that can hold multiple data entries (values) of the same data type. 

For example, EmailAddress can be a variable that holds the value "rpadeveloper@uipath.com". 

The value of a variable can change through external input, data manipulation or passing from one
activity to another.

Why are they important?

Variables help us pass data from one activity to another. Advancing with any automation process would
be hardly possible without using variables.

Variables are configured through their properties. You can set them in the Variables panel. The main
properties in UiPath are:

Name
–

It should be as descriptive as possible to make your automation easy to read by other developers and to
save time. While not the only option, we recommend using PascalCase for variable names. 

The variable's name is its unique ID and it defines the way it is displayed and used. 

Type
–

It defines what kind of data can be stored in the variable. In UiPath, the type is declared when the
variable is created, however there are some types that can accommodate different types of data. 

Default Value
–

In general, variables have initial values that change throughout the process. For most variables, if no
initial value is assigned when the variable is declared, there is a default rule that assigns a value. 

Scope
–

The part of the workflow in which the variable can be used. Some variables can be global (used
throughout the workflow), others local (used inside an activity). 

In real automation scenarios, there are many variables in use. Making all of them unnecessarily global
can cause efficiency issues as well as create the conditions for confusion.

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.

Creating Variables
There are three main ways to create variables in UiPath:

From the Variables panel

–

Navigate to the Variables panel, select the ‘Create Variable’ line and type in the name. Whenever
needed, provide its name in the Designer panel or in the desired Properties field.

From Expressions
–

Variables can be created from expressions directly in an activity input field or the Expression Editor.
Select a part of the expression and press Ctrl+K. 

The Set Var field is displayed. Fill in the name and press Enter. Check its type and scope in the Variables
panel.

From the Properties panel

–

In the Properties panel of any activity, select a field that can be edited press Ctrl+K. The Set Var field is
displayed. Fill in the name and press Enter. 
Check its type and scope in the Variables panel.

What is a workflow?

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.

UiPath Studio provides you with predefined workflow layouts to suit all the needs of a fast and reliable
automation process.

The workflow layouts are:

  Sequences
 Flowcharts
 State Machines
 Global Exception Handler

Why is it important?
The fastest, most reliable, and useful way of automating a process is to break it down into smaller bits. 

This allows for independent testing of components, enables team collaboration, and component reuse. 

Hence, most of the automation projects require the use of multiple workflows that come together to
provide a solid business automation solution.

What is an argument?
Arguments are very similar to variables: 

 They store data dynamically

 They have the same data types
 They support the same methods and properties

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.

Why are they important?

Arguments are a key component when it comes to building more complex automations, where you need
to store and use data between multiple workflows.

Creating arguments
Argument names should be in PascalCase with a prefix stating the argument direction, such as
in_DefaultTimeout, in_FileName, out_TextResult, io_RetryNumber.

From expressions
–

Directly in an activity input field or the 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.

Fill in the name and press Enter. The argument is created. Check its direction and type in the Arguments
panel. Arguments created in these ways automatically receive the type according to the activity.

From the 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.
Fill in the name and press Enter. The argument is created and visible in the field. Check its direction and
type in the Arguments panel. The argument type is automatically generated depending on the selected
property.

From the Arguments Ppanel

–

Navigate to the Arguments panel. Select the Create Argument line, and fill in the name, direction and
type. A new argument is created.

Data Types
With some exceptions that we will discuss separately, the data types in UiPath are borrowed from
VB.Net. Below are some of the most common ones used:

String
–

System.String: Used to store text. This type of data comes with many specific methods of processing,
and will be addressed in depth in another lesson, namely Data Manipulation.

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

Boolean
 System.Boolean: Used to store one of two values – True or False.
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.

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.
Date and Time (category)
–
  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.

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.

Arrays
Most of the examples shown up to this point were simple variables and arguments, which can store a
single value at a time. It’s time to look at a collection: the array.
What is it?
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.

What are some business scenarios in which I will use arrays?

 When we want to save the names of the months to a variable.

 When a fixed collection of bank accounts has to be stored and used in the payment process.
 When all the invoices paid in the previous month have to be processed.
 When the names of the employees in a certain unit have to be verified in a database.

GenericValue

 While developing an automation process, there are situations where you are not sure what type
of data will be retrieved. In order to find out, you need to run a few tests using a variable with a
broad enough spectrum that can catch any type of input. 
 This is where we recommend temporarily using GenericValue Variables. 
What is it?
The GenericValue (UiPath.Core.GenericValue) data type is particular to UiPath and can store any kind of
data, including text, numbers, dates, and arrays.
UiPath Studio has an automatic conversion mechanism of GenericValue variables and arguments, which
you can guide towards the desired outcome by carefully defining their expressions.

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. 

If it is defined as an Integer, the result is their sum.

What are some business scenarios in which I will use GenericValue?

 Data is extracted from a UI field and forwarded to another workflow without processing.
 Two versions of the same Excel file are being compared column by column. The columns are
different in terms of data type, the only relevant thing is which entries have changed. 

What is control flow?

 It is the order in which activities are executed or evaluated in a software project. 

 There are two concepts through which the control flow is enacted:

The workflow layouts

There are 4 predefined workflow layouts – Sequence, Flowchart, State Machine and Global Exception
Handler.

1. 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.
2. 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.

The 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.
What are some business scenarios in which I will use the If statement?
Whenever there are two courses of action that are not arbitrary, an If statement will most likely be
used:

 Checking the status of a payment (done/not done) and performing a set of operations in each
case.
 Making sure that the outcome of the previous operation in the sequence is successful.
 Checking the balance of an account to ensure that there is enough money to pay an invoice.
 Checking if something has happened in a system like, if an element or an image exists and
performing an action based on that.


What are they?

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

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.
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.
How do I exit a loop?
Loops are fun, but we should know how to stop the ride at some point. There are multiple ways to exit a
loop:
 The While and Do While loops will exit when upon checking, the condition is no longer true.
 The For Each loop will exit when it has finished processing every item in the input collection.
 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.

Switch
What is it?
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.

What Is UI Automation?
What is it?
User interface or graphical user interface automation (UI automation) refers to the process of
interacting with graphical elements within applications by simulating mouse and keyboard controls.
Just as human users use applications through activities such as clicking, typing, or selecting text, UiPath
Robots can be configured in UiPath Studio by RPA Developers to perform the same tasks faster and
error-free.

Through a deep integration between UiPath and all of the major GUI frameworks from Win32 to WPF,

HTML, and Java, RPA Developers can easily automate all types of desktop applications.

UiPath recognizes graphical objects by its own platform-specific attributes and provides a unified GUI

automation API that works the same way everywhere.

How should you view UI automation?

Considering that robots will perform actions in application user interfaces (UIs) just as humans would,
RPA Developers will need to configure each action in a logical, sequential path. 

Main takeaways
–

 UI automation is the process of automating application user interfaces by simulating human

input and output actions through specific UI activities.
 The first step in automating UIs is understanding the logical sequence of steps that a human
user would take. The second step consists in translating these steps into UiPath Studio activities
and configuring them.
 The complexity of the UI or of the application is irrelevant. All desktop applications can be
automated by using universal or application tailored activities.

UI automation is built upon seven key concepts. These are:

 11 UI automation activities
 22 Activity properties
 33 Targeting methods
 44 Input and output methods
 55 Recorders and wizards
6 The object repository
7 7 AI Computer Vision
UI automation activities

UI Automation activities let developers quickly write instructions for the Robot to interact with the
interfaces of various applications. Activities can be split into:
  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. 

Activity properties

Just like for other types of activities, properties determine how the robot performs an action. They can
be found in the Properties panel. UI automation activities have specific sets of properties depending on
the type of activity. Here are a few examples of common properties:

Property What it does

How many milliseconds the Robot waits before or after
DelayAfter/DelayBefore
executing the activity.
Will an exception encountered while executing the activity
be thrown or ignored. For example, if the element is not
ContinueOnError
found, will the Robot throw an error and stop the
execution, or will it ignore and continue?) 
Provides several properties related to identifying the target
Target
UI Element.
How many milliseconds will the Robot try to perform an
Timeout (milliseconds)
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.
Numbered divider 3
Targeting methods

Targeting methods are a subset of Properties. They provide several ways to identify the UI element the
Robot will be interacting with. The key targeting methods are:

 Selectors 
 Fuzzy Selectors 
 Image  
 Anchors 
The most commonly used targeting method is the selector.

Input and output methods

As we've discussed already, every time we insert data into an application, or we send a command to a
system to produce a change (or to continue), we perform an input action. Output actions are used in
UiPath either to extract data (in general, as text) from a UI element. Output methods are what enables
output actions to extract data from UI elements. 

UiPath provides several methods to perform input and output actions. These methods control several
important aspects of our automation: 
 bullet
How fast will the action be performed?
 bullet
Can the action run on a background or a hidden window?
 bullet
Does it interfere with the user?
 bullet
Is it compatible with all apps?
Different methods are available for input and output activities.

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.

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

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. 

Main takeaways
–

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

What are design experiences?

So far, we've learned about UI automation in general. There's one last thing you need to understand
before using these features—UiPath Studio offers two ways of developing UI automation: the Classic
Design Experience and the Modern Design Experience. 

These design experiences help developers adapt to different contexts while building the UI automation.
The default design experience is set at project level from Project Settings or for all new projects from

the Backstage View > Settings > Design. When starting out, the default experience is Classic.  

For all New projects

For all new projects, we can set this from  Backstage View > Settings > Design. When starting out, the

default experience is Classic.  

What are the differences?

The key differences between classic design experience and the modern design experience are based on
the following Key concepts:

1 UI automation activities

2 Activity properties

 3 Targeting methods
 4 Recorders and wizards
 5 The object repository

UI automation activities
A separate set of UI activities is available by default in each experience. Regardless of the selected
experience of an automation project, modern or classic, the other set of activities can be enabled.

If the default experience is classic, to view the modern activities simply select the "Show Modern" from
the Activities panel, or vice versa.
A great example would be the
Use Application/Browser modern activity
which replaces the following Classic Activities:
- Open Application
- Open Browser
- Attach Window
- Attach Browser
- Element Scope
- Close Window
- Start Process.

Activity properties
Classic and modern activities have slightly different properties because of different targeting methods
and activity behaviors. We will learn more about this in the following lessons.
Targeting methods

Image from the Modern Experience Capture Elements wizard which shows the targeting methods

stacked.

When using classic activities, the selector is the most common targeting method for UI elements (99%

of the time). In scenarios where it is unreliable, you have the possibility to manually change update the

activity to use a fuzzy selectors or anchors.

Modern activities will cycle through the stacked options Selector, Fuzzy Selector, Anchor, and Image to

determine the most reliable option in the order we have just presented them. In case the previous

method is not reliable, it will automatically choose the next one. This targeting technology is

called Unified target. 

Recorders and wizards

Modern and classic offer two different sets of recorders:

 Modern experience - The App/Web and Computer Vision recorders are available.
 Classic experience - The Basic, Desktop, Web, Image, Native Citrix, and Computer Vision
recorders are available.

When it comes to Scraping Wizards:

 Modern experience - The Table Extraction wizard is available for data scraping.
 Classic experience - The Data Scraping and Screen Scraping wizards are available.
 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. The Object Repository
is only available in the Modern Design Experience.
 Don't worry about remembering all of this. It's useful to know what the key areas of difference

are and you can reference this course later if you need to.

Main takeaways
–
  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: 
o Activities: Both experiences provide different activities, but you can filter the Activities
pane to see the ones from the non-default experience.
o Activity properties: The properties are slightly different between the Modern and
Classic activities.
o Targeting methods: Classic uses mostly selectors, while modern uses Unified Target (a
stack of Selector, Fuzzy Selector, Anchor and Image).
o Recorders: Modern offers a simplified recording solution with two recorders, while
classic offers six recorders.
o Scraping wizards: Modern offers the Table Extraction wizard while classic offers the
Data Scraping and Screen Scraping wizards.
o Object repository: The object repository is only available to the modern design
experience. 

Enabling the Modern Design Experience

The modern design experience is not enabled by default. The below video will help us to learn the
following:

 How to change between modern and classic activities.

 How to set your new automation projects to a default design experience.
 How to change the design experience at the project level.
 Hello and welcome to this introduction to the UI Automation Design Experiences. In this video,
we will get an overview of the two methods offered by UiPath Studio for
developing Projects that automate user interfaces: Modern and Classic.  
   
 More specifically, we’ll use the Modern App-Web Recorder, make the switch between
the two Design Experiences in Studio, then spend some time on the differences and similarities
between the two and the targeting methods that they use.   
  
 We’ll start with the Modern Design Experience. It is available both in the Studio and Studio Pro
profiles, and it’s the only one available in StudioX. It offers a simplified way of working
with browsers and applications.   
  
 Let’s first have a look at the Recorder.   
   
 We can access it by clicking its icon on the Design Ribbon. The Recorder generates a UI
Automation sequence of activities, based on the steps we take on the screen.  
 
To get started, we need to click “Start Recording”, and indicate the application we want to
record, in our case “Double UI”.  
  
 Once we’ve selected the application, we can indicate the UI Elements we want to
capture. Let’s indicate the “Cash In” field.    
  
 As you can see, after we’ve indicated the field, the Recorder has identified it as an input field.
It asks us for the value to be inputted there, or a source of the data, like a variable. Let’s go for
the latter in this example. We’ll just right-click the field and select Create Variable. We’ll call
it “Cash In”, … and click “Confirm”. 
  
OK! We’ve recorded a set of steps which attach to the Double UI application and enter the value
in the “Cash In” variable into the “Cash In” field of the application. It’s enough for our purpose
here. 
   
 Let’s select “Save & Exit” from the recorder, and return to Studio, where we can see what
the generated sequence looks like. We have an application card and a Type Into activity. 

 The Application card indicates the target application ... so all the UI Interaction Activities within
the “Do container” will target only elements present in the target
application. Various activities are available for providing UI Interaction instructions, like Click,
Type into, Get Text and so on.   
  
 All the activities can be found in the Activities panel under “UI Automation”, “Application”.  
  
 So far in this example, we’ve seen the Modern Design Experience in action. Before doing the
same using the Classic experience, let’s see how we can switch between the two. This can be
done at project level or at Studio level, as the default option when starting new projects. We'll
go for the project level now. Access the Project Panel, then click Project Settings.  
  
 The Project Settings window is displayed. In the General section, we can see the Modern Design
Experience toggle.   
  
 Let’s set it to “No”... and reload the project. This means that we are currently
running the Classic Design Experience.   
  
We can notice some differences right away: we have the Classic Recorders available, the Object
Repository is disabled … and the Activities displayed in the Activities panel are of the Classic
type.   

 But, even if we have switched to the Classic Design Experience, the modern activities will still
work, since they are included in the “UiPath UI Automation Package” versions 20.10 and later.  

 However, based on the Design Experience toggle, only specific activities will be displayed in the
Activities Panel.   

 If we want to add a Modern “Type Into” Activity while in the Classic Design Experience,  we can
click the Filter Button in the Activities panel ... and enable “Show Modern”.   

 And here they are, under the Modern node in the Activities panel!   
 The same can be done when running Modern, so let’s quickly switch to the Modern Design
Experience, and try to add Classic activities.  

 As you can see, the default UI Activities displayed are of the Modern type.    
 But if we enable “Show Classic”, ... we will be able to see both modern and classic activities.  

 The classic activities that do not have a counterpart in the Modern Design Experience will be
available all the time regardless of the filter option we set.  

 An example would be the “Find Element” activity, which can be used in the modern Application
Card already added to our workflow. As a matter of fact, we can use all Classic UI activities in
Modern Application cards.  

 Moreover, we can also pass output data between classic and modern activities.   

 For example, let’s add a classic “Attach Browser” activity.   

 The UI Browser output here can be used ... as input for the modern Application card, and vice
versa.  

 The same can be done for other classic activities such as “Open Application” or “Open
Browser”.  

 We’ll remove this for now since we don’t need it.  

 So far, we’ve switched between the Classic and Modern Design Experiences at project
level. Let’s see how we can set one of the two as default for all new projects in Studio.   

 So, let’s access the Backstage View. We have a new parameter under Settings, Design, called
“Use Modern for new projects”.  

 By using this toggle, we can set the default to either use the modern or classic design
experience for all new projects from now on.  

 Now, let’s go back to our workflow and have a quick look at the targeting methods.  

 Modern Activities use Unified Target to identify UI Elements on the screen. Unified Target is in
fact a stack of targeting methods: Selectors, Fuzzy Selectors, Image, and Anchors. The
robot uses them in a given order, and if one fails, it tries the next one.

Classic activities tend to use only one targeting method, by far the most common
being Selectors. 

 From the Modern Recorder, we can directly edit Selectors using the UI Explorer, which offers us
more control.  

 Going back to Studio, in the activity Properties, we have access to target details such as
the Targeting Methods, Selector, Fuzzy Selector, Window Selector and Anchor.  

 And this brings us to the end of our demo on the UI Automation Design Experiences. 
 
For a quick recap, in this video we’ve got a quick view of the Modern App/Web
 Recorder, we’ve seen how we can switch between the Modern and Classic Design Experiences
at project and Studio levels and we’ve explored the differences between the two in terms of
Recorders, Object Repository, Activities and Targeting Methods.   
 

What are DataTables?

 DataTable is the type of variable that can store data as a simple spreadsheet with rows and
columns. You can identify each piece of data based on its unique column and row coordinates.
Think of it as the memory representation of an Excel worksheet. 
 In DataTables, the regular convention of identifying the columns and the rows is applied -
columns are identified through capital letters, and rows through numbers.

How are DataTables created?

 The most common activities and methods to create DataTables are: 
The Build Data Table Activity
By using this activity, you choose the number of columns and the data type of each of them.
Moreover, you can configure each column with specific options like allow null values, unique
values, auto-increment (for numbers), default value and length (for strings).
The Read Range Activities
This activity gets the content of a worksheet (or a selection from that worksheet) and stores it
in a DataTable variable, which can be created from the Properties panel using Ctrl + K.
The Read CSV Activity
–

This activity captures the content of a CSV file and stores it in a DataTable variable. Although not
commonly used anymore, there are still legacy or internal-built applications that work with this kind of
documents.
The Data Scraping Action
–

This functionality of UiPath Studio enables you to extract structured data from your browser, application
or document to a DataTable.
The Generate Data Table From Text Activity
–

Can be used to create a DataTable from structured text, by letting the user indicate the row and column
separators.

We will create two Data Table variables and merge their values together, and then we’ll filter the
unwanted columns out. In the end, we will sort the rows of the resulting DataTable in ascending order. 

But first, let’s go through the basics: Data Table variables store data structured in a tabular form, - that
means any information organized in rows and columns. This variable type is similar to a spreadsheet.  
As a key difference, Data Table cells are individually identified through the Column Name or Column
Index and the Row Index with both indexes starting from 0. Spreadsheet cells are individually identified
through the Column letter and the Row number which starts at 1. 
UiPath Studio includes many activities that output Data Table variables. In this demo, we will focus on
the Build Data Table activity, which is largely used to define the structure of a Data Table.  

For this demo, we have already configured two Build Data Table activities. Let’s examine the first
example to see all the configuration options. 

The Build Data Table window enables us to set the number of columns in our data table and the type of
data they contain. 

Let’s click the Edit button to see more Column configuration options.  

The Edit Column window is displayed. The first field we see is the Column Name. This value can be used
to reference this column in our process. 

Next, we have the Data Type field. The columns can comprise any type of data. We can browse for types
and select the ones that suit our automation scenario.  

There are some additional column customization options. We’ll take a quick look at them before moving
on.  

The Allow Null checkbox allows for specifying if the column can contain blank cells. 
Next, the Auto Increment feature is available only if the Data Type is set to Int32. If selected, the value
of this column is automatically incremented by 1 every time a new row is added.
Since our type is String, it’s currently not available for us.  

We can add any default cell value in the Default Value field.  

If we select the Unique checkbox, we can make sure that all the values are different from one another.
That can be of great help when dealing with types of data such as user IDs, to ensure a high-quality
output.  

We can also adjust the maximum length of the value in a cell.  

Let’s click OK to return to the Build Data Table window. 

We can easily rearrange the columns by dragging and dropping them to the intended position. 

For demonstration purposes, we’ve used the Build Data Table activity to add values to our DataTable
variables. In business scenarios, however, there are many efficient ways to achieve that. For example,
the Read Range activity captures the data in a spreadsheet and stores it in a DataTable variable.  

In this demo, we’ll work with two predefined DataTable variables. The first one, “Users”, contains
information about the members of a library – their name, unique ID, department, and phone number.
The second variable, which is called “OverdueBooks”, contains data related to all the currently borrowed
books – the author's name, the title, the unique book ID, as well as the ID of the borrower. 
Next, we want to collect the names and phone numbers of the library members with overdue books and
store them in a single variable. To do that, let’s add a Join Data Table activity... and open the Join wizard.

The Join Data Table activity combines rows from two tables by using values common to each other,
according to a Join rule. 

The Join wizard helps us configure the properties of the Join Data Tables activity.  
The Input and Output Data Table fields let us control which tables need to be joined and where we want
to store the result. 

The Join Type property determines the type of Join operation we want to use. Our options are Inner,
Left and Full.  

In our case, the join type is Inner, because our resulting data table must include rows extracted from
both our tables according to the join rule we will configure. Any rows that do not meet the rule are
removed from the resulting table.  

The data table we’ll provide in the Input DataTable 1 field is “OverdueBooks”, as there might be
members who borrowed multiple books. 

The “Users” variable goes in the Input DataTable 2 field.  

Let’s create a new variable for the output. We’ll call it “BorrowedBooks”.  
Now it’s time to determine the join criterion. We want to join all rows which have the same value in the
“ID” column. To do this, we’ll select the equal operation and enter the names of the two ID columns.  

We’ve just finished configuring the Join Data Table activity, so we can click OK. 

Let’s proceed to the next activity in the workflow! To be able to print our result to the Output panel,
we’ll use the Output Data Table activity, which converts an input data table to a String variable.  

The input is BorrowedBooks... and the output needs to be stored in a new string variable. Let’s hit Ctrl +
K and name this variable “BorrowedBooksString”.  

We’ll also change the name of the activity to “Output BorrowedBooks to text” for increased workflow
readability. 

We’ll display the content of the variable we have just created using a Write Line activity. 
Let’s run the workflow! 

The Output panel displays the correct results, so our project works as expected. However, there are
some unneeded details that we can filter out to prevent clutter. Specifically, the ID column is included
twice, and the Department one is not relevant. As a result, we’ll use two Remove Data Column activities.
Let’s place them above the Output Data Table activity.  

The first one will remove the duplicate column from the BorrowedBooks data table. 
Since both ID columns have the same name, let’s use the index of the column we want to remove, which
is 6. We’ll also rename this activity.  

Now we can move on to the next one. Once again, the data table is BorrowedBooks. Now, we can use
either the Index or the Name to identify the column to be removed, so we can type “Department”
between quotation marks.  

Let’s run the workflow again… Great! The unwanted columns have disappeared. 

Now, for the last touch, let’s sort the data according to the user ID, to make sure that users are
contacted to return all the books they have borrowed.  

Let’s add a Sort Data Table activity right before the Output Data Table one. We will add the
BorrowedBooks variable both as input and as output variable... and the “ID” column in the Name input
field under Sorting Column. By default, the Order is ascending. We’ll leave it as it is. Alright! Let’s run this
one more time. 

UiPath offers a broad range of activities that can be used to work with DataTable variables: 
Add Data Column
–

Adds a column to an existing DataTable variable. The input data can be of DataColumn type or the
column can be added empty, by specifying the data type and configuring the options (allowing null
values, requesting unique values, auto-incrementing, default value and maximum length). 
Add Data Row
–

Adds a new row to an existing DataTable variable. The input data can be of DataRow type or can be
entered as an Array Row, by matching each object with the data type of each column. 
Build Data Table
–

Is used to create a DataTable using a dedicated window. This activity allows the customization of
number of columns and type of data for each column. 
Clear Data Table
–

Clears all the data in an existing DataTable variable.

Filter Data Table
–

Allows filtering a DataTable through a Filter Wizard, using various conditions. This activity can be
configured to create a new DataTable for the output of the activity or to keep the existing one and filter
(delete) the entries that do not match the filtering conditions.
For Each Row in Data Table
–
Is used to perform a certain activity for each row of a DataTable (similar to a For Each loop).
Generate Data Table From Text
–

Can be used to create a DataTable from structured text, by letting the user indicate the row and column
separators.
Join Data Tables
–

Combines rows from two tables by using values common to each other using the Join Wizard, according
to a Join rule that answers the question "What to do with the data that doesn't match?". It is one of the
most useful activities in business scenarios, where working with more than one Data Table is very
common. This is why we'll cover the topic more in-depth in the next lessons.
Lookup Data Table
–

It is similar to vLookup in Excel. You can search for a provided value in a specified DataTable, and the
RowIndex returns its value.  Or it can be configured to return the value from a cell with the given
coordinates (RowIndex and Target Column).
Merge Data Table
–

Is used to append a specified DataTable to the current DataTable. The operation is more simple than the
Join Data Type activity, as it has 4 predefined actions to perform over the missing schema.
Output Data Table
–

Writes a DataTable to a string using the CSV format.

Remove Data Column
–

Removes a certain column from a specified DataTable. The input may consist of the column index,
column name or a Data Column variable.
Remove Data Row
–

Removes a row from a specified DataTable. The input may consist of the row index or a Data Row
variable.
Remove Duplicate Rows
–

Removes the duplicate rows from a specified DataTable variable, keeping only the first occurrence.
Sort Data Table
–

Can sort a DataTable ascending or descending based on the values in a specific column.
Get Row Item
–
Retrieves a value from a row in a DataTable according to a specified column.
Update Row Item
–

Assigns a specified value to the indicated column of a DataTable row.

Focus: Joining DataTables

How does it work?
1 Three Data Table variables have to be specified - two Input DataTables and one Output
DataTable. Please note that the order of the first two is very important, as there is one option
that keeps the values from Data Table 1 and it cannot be changed. 
2 The Join Type has to be chosen - there are three options:

 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.
2 3
3 The Join rules have to be configured (there can be one or more rules):

 One column from each DataTable has to be specified by their names (String), by their
index (Int32) or by ExcelColumn variables
 The operator has to be chosen: = (Equal to), != (Not equal to), > (Greater than), < (Less
than), >= (Greater than or equal to), <= (Less than or equal to)

What are some business scenarios in which I will use

Join Data Tables?
Join Data Table provides one of the easiest ways to bring data from two sources in one place: 
 Bringing together 2 databases of employees extracted from 2 applications
 Checking which of the clients (database 1) have been contacted in a marketing campaign
(database 2)
 Checking which of the suppliers of a company (internal database) have applied for public aid
(public database)

Workbooks and 
Common Activities
In many business scenarios, databases are stored in workbooks (generally known as Excel files
or spreadsheets). These databases can be processed into DataTables using the methods we
learned in the previous chapter and other alternate methods, and tools. It is time to see how RPA
deals with workbooks. 

UiPath offers 2 separate ways of accessing and manipulating workbooks:

 bullet
Workbook or File Access Level
 bullet
Excel or Excel App Integration

Each of them comes with advantages and limitations.

Workbook - File Access Level

–

All workbook activities will be executed in the background.

(+) Doesn't require Microsoft Excel to be installed, can be faster and more reliable for some
operations just by not opening the file in the Excel application;

(!) Works only for .xls and .xlsx files.

(!) Doesn't work with .xlsm files.
(!) The file should not be open in Excel at runtime.

Excel - Excel App Integration

–

UiPath will open Excel just like a human would.

(+) Works with .xls, .xlsx and .xlsm, and it has some specific activities for working with .csv. All
activities can be set to either be visible to the user or run in the background. The file can be open
in Excel at runtime.

(!) Microsoft Excel must be installed even when the 'Visible' box is unchecked. If the file isn't
open, it will be opened, saved, and closed for each activity.

Both access levels share some activities, with Excel App Integration having several more.
Note: In Studio, in the Activities panel, we can find Excel activities under 'App
Integration > Excel', and Workbook activities under 'System > File > Workbook'.

Let's start with the common activities:

Append Range
–
Adds the information from a DataTable to the end of a specified Excel spreadsheet. If the sheet
does not exist, it creates it.
Get Table Range
–

Locates and extracts the range of an Excel table from a specified spreadsheet using the table
name as input. 
Read Cell
–

Reads the content of a given cell and stores as a String.

Read Cell Formula
–

Reads the formula from a given cell and stores it as a String.

Read Column
–

Reads a column starting with a cell inputted by the user and stores it as an IEnumerable <object>
variable.
Read Range
–

Reads a specified range and stores it in a DataTable. If 'Use filter' is checked in the Read Range
activity under 'Excel Application Scope', it will read only the filtered data. This option does not
exist for the Read Range activity under 'Workbook'.
Read Row
–

Reads a row starting with a cell input from the user and stores it as an IEnumerable <object>
variable.
Write Cell
–

Writes a value into a specified cell. If the cell contains data, the activity will overwrite it. If the
sheet specified doesn't exist, it will be created.
Write Range
–

Writes the data from a DataTable variable in a spreadsheet starting with the cell indicated in the
StartingCell field.

The Excel Application Scope

The integration with Excel is enabled by using an Excel Application Scope activity. It is a

container and all the other Excel activities used to work with the specified Excel file have to be

placed inside the container. When the execution ends, the specified workbook and the Excel

application are closed.

The Excel Application Scope can be configured to write the output of the activities in the

container in a different file.

Important note: If the same workflow deals with information from two or more Excel files, an
Excel Application Scope has to be used for each file.

The Excel App Integration specific activities

CSV Activities
–

These activities can read from and write to CSV files, using DataTable variables. Although
found under Excel App Integration, they work even if they are not placed inside an Excel
Application Scope container.
 Append to CSV: add the info from a DataTable to a CSV file, creating it if it doesn't
exist. The activity does not overwrite existing data
 Read CSV: reads all entries from a CSV file and store them in a DataTable 
 Write CSV: overwrites a CSV with the information from a DataTable

Range Activities
–

These activities can read data, insert and delete rows and columns, and even copy/paste entire
ranges. They are similar to the corresponding activities under DataTable, but they work directly
in the Excel file.
 Delete Column: removes a column from an Excel file based on the name.
 Insert Column: inserts a blank column in an Excel file, at a certain position.
 Insert/Delete Columns: either adds blank columns or removes existing columns, based
on the specified change type.
 Read Column: Reads the values from a column beginning with the cell specified in the
StartingCell property field, and stores them in an IEnumerable<Object> variable. 
 Insert/Delete Rows: either adds blank rows or removes existing rows, based on the
specified change type.
 Select Range: selects a specific range in an Excel file. In general, it is paired with
another activity that performs a certain manipulation over the selected data.
 Get Selected Range: outputs a given range as String.
 Delete Range: removes a specified range from an Excel file.
  Auto Fill Range: applies a given formula over a given range in an Excel file.
 Copy Paste Range: copies and pastes an entire range (values, formulas and formatting)
from a source sheet to a destination sheet.
 Lookup Range: searches for a value in all the cells in a given range.
 Remove Duplicate Range: deletes all duplicate rows from a given range.
 Read Range: Reads the value of an Excel range and stores it in a DataTable variable. If
the range isn't specified, the whole spreadsheet is read. If the range is specified as a cell,
the whole spreadsheet starting from that cell is read. 
 Append Range: Adds the information stored in a DataTable variable to the end of a
specified Excel spreadsheet. If the sheet does not exist, a new one is created with the
name indicated in the SheetName field.
 Write Range: Writes the data from a DataTable variable in a spreadsheet starting with
the cell indicated in the StartingCell field. If the starting cell isn't specified, the data is
written starting from the A1 cell. If the sheet does not exist, a new one is created with the
value specified in the SheetName property.

Table Activities
–

These activities create, filter and sort tables directly in Excel files.
 Filter Table: applies a filter on all the values from a column in a table inside an Excel
file. Once the file is saved, only the rows that meet the filter will be displayed. Please
note that this activity does not remove the rows that do not meet the criteria, but only
hides them. A good use of this method involves using a Read Range activity after this
one, with 'Use filters' box checked. The output will be a DataTable containing only the
entries that met the given criteria.
 Sort Table: sorts a table in an Excel file based on the values in a given column.
 Create Table: it creates a table (with name) in a range specified in the Properties panel.

File Activities
–

These activities work directly with the Excel files, either by saving or closing them.
 Close Workbook
 Save Workbook

Cell Color Activities

These activities are able to capture and modify the background color of cells in Excel files.

 Get Cell Color: reads the background color or a given cell in an Excel file and stores it
as color variable output.
 Set Range Color: changes the background color of all the cells in a given range. The
input is a color variable.

Sheet Activities
These activities can perform various actions over the sheets in an Excel file.
  Get Workbook Sheet: reads the name of a sheet by its index.
 Get Workbook Sheets: extracts the sheet names and stores them ordered by index.
 Copy Sheet: copies a sheet in an Excel file and pastes either in the same Excel file or in a
different one specified.

Pivot Table Activities

These activities facilitate working with pivot tables in Excel files.

 Refresh Pivot Table: refreshes a pivot table in an Excel file. This is useful when pivot
table source data changes, as the refresh is not automatic.
 Create Pivot Table: creates a pivot table using a specified sheet and given parameters.

Macro Activities
These activities can execute macros that where already defined in the Excel file, or can invoke

macros from other files. Please note that these activities work with .xslm files.

 Execute Macro
 Invoke VBA: macro from another file

What is data manipulation?

Data manipulation is the process of modifying, structuring, formatting, or sorting data in order to
facilitate its usage and increase its management capabilities. 
What are some business scenarios in which I will use data manipulation?

 Data manipulation methods are frequently employed by website owners to extract and
view specific information from their web server logs. That allows for watching their most
popular pages, as well as their traffic sources.
 Consider the process of interrogating public financial or legal databases. Data
manipulation provides the means for the credit analysts to extract only the relevant data
and use it in other documents or correlate it with information from other sources.

What are they?

Strings are the data type corresponding to text. It is difficult to imagine an automation scenario
that doesn’t involve the use of strings.

Anytime a text needs to be captured, processed, sent between applications, or displayed, strings
come in handy (unless the data is structured - like a table).
What are some business scenarios in which you will most likely encounter
strings?

 Getting the status of an operation.

 Extracting the relevant piece from a larger text portion.
 Displaying information to the human user.
String methods
 String manipulation is done by using String Methods borrowed from VB.Net.
Below are some of the most common methods used in RPA.

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

What are they?
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.

What are some business scenarios in which you will most likely encounter lists?

 Storing the computer names of the members of a project team for a certain configuration
that needs to be made.
 Collecting and storing the numbers of invoices that meet certain criteria.
 Keeping track of the ticket numbers created in a certain period on a certain issue.

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.

 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.
 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.
To start using reference types like Lists and Dictionaries, we need to go through 3 steps: declare,
instantiate, and assign the object.

1 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.
  2

2 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).
 3
3 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.

UiPath methods applicable to collections

Manipulating lists can be done using .NET methods or using the collection methods that UiPath
Studio offers.

Add to Collection
–

Adds an item to a specified collection. It is equivalent to List.Add(). It can be used, for example,
to add a new name to a list of company names.
Remove from Collection
–

Removes an item from a specified collection and can output a Boolean variable that confirms the
success of the removal operation. This activity can be used, for example, to remove an invoice
number from a list of invoices to be processed.
Exists in Collection
–

Indicates whether a given item is present in a given collection by outputting a Boolean as the
result. We can use this activity to check whether a list of clients contains a specific name.
Clear Collection
–

Clears a specified collection of all items. One possible use is to empty a collection before starting
a new phase of a process that will populate it again.
What are they?
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.

What are some business scenarios in which you will most likely encounter
dictionaries?

 Storing configuration details or other information that needs to be accessed throughout a

process.
 Storing the job titles or other relevant information of employees.
 Storing the bank accounts of suppliers.

Methods for working with Dictionaries

Initialization
–

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. 
Adding Key-Value Pairs
–

VarName.Add(Key, Value) – adds an item to an existing Dictionary. Because Add does not
return a value, we use the Invoke Method activity.
Removing Keys
–

VarName.Remove(Key) – removes an item from the Dictionary. It can be used in an ‘Assign’

activity.

Retrieving
–

 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

What is it?
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.

What are some business scenarios in which I will use RegEx?

Retrieving pieces of text that follow a certain pattern, for example:

 extracting phone numbers that start with a certain digit.

 collecting all the street names from a bulk text, even if they don't follow a specific pattern
- some of them contain "Street", others "Rd.", and so on.

It would take much longer to build the same expression using the regular String methods – for
example, RegEx has a predefined expression to locate all the URLs in a string.
Methods in UiPath that use the RegEx builder
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

What is it?
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.

What are some business scenarios in which I will use DateTime?

Working with time-sensitive documents such as invoices in scenarios where:

 the time format varies throughout the process.

 a specific amount of time needs to be added or subtracted while processing documents.

Methods that can be used with DateTime variables in UiPath

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.
What are 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.
What are some business scenarios in which selectors are useful?
Most of the times when an automated process involves working with UI elements, selectors are
used. Typical activities include:

 Clicking buttons.
 Inputting or scraping text in/from a field on a website.
 Choosing an option from a drop-down list.

The structure of a selector

User Interfaces (UIs) are built using a series of containers nested one inside the other.
Let’s take the example of a selector for the First name input field in MyCRM
Application, and try to understand the meaning of the structure.

Tags & Attributes of Selectors

As you saw, selectors are made of nodes. And each node is made of tags and attributes.
Let's take an example to explain the two. Below is a selector node.

<webctrl parentid=‘slide-list-container’ tag=‘A’ aaname=‘Details’ class=‘btn-dwnl’ />

Tags
–

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

Attributes
–

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’

The UI Explorer
What is it?
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.
What are some business scenarios in which I will use the UI Explorer?
The UI Explorer can be used whenever the selectors that were automatically generated are not
stable or reliable enough. For example, when: 

 The selectors change from one execution to another.

 The selectors might change following product updates.
 The selectors use unreliable info, such as index.

The UI frameworks
In order to return the best selector for the element of interest, we can switch
between the different UI frameworks available in UiExplorer.

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.

The Property Explorer

What is it?
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).

Types of Selectors
As previously presented, selectors are automatically generated when UI elements are
indicated inside activities or when the recorder is used. Knowing the difference between
full and partial selectors is very important when activities generated inside containers are
moved outside, or the other way around. 

The UI automation classic experience containers are Attach Window, Attach Browser
and Open Browser.
Full selectors
–

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

When are partial and full selectors used? 

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.

What is 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. 
What are some business scenarios in which fine-tuning is required? 

 The workflow uses files that have timestamp in the name.

 The environment in which a workflow was built has different parameters than
the production environment (for example, the application version).
 The use of dynamic selectors would improve the reliability and robustness of
the automation.
When exactly is fine-tuning of selectors required?

 bullet

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.
How can we fine-tune selectors?
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}}'/>