Hello.
welcome to the UIPath introductory training.
In this tutorial you will get to know the basics of automation and working with UIPath.
Some elementary knowledge of programming concepts – like variables, if/else decision, and
loops – would be helpful, but even if this is your first time hearing about these notions,
you should be fine, as we’ll try to explain everything as we go.
You've already learned about installing and opening UiPath in the previous training, so let's
first get to know where everything is.
When you first start UiPath, you will see this welcome screen, where you have the option
to start a new project or open a recent one.
we'll start with a blank project.
We’ll call it… intro.
The interface is straightforward.
Besides the conventional toolbar, there are three main areas that you will work with.
0n the left side is the activities panel.
Activities are actions that we will use to automate different applications – like clicking
& typing – and other data-processing actions.
There are lots of activities and you can find the right one by searching its name
here.
But more about that later.
The big area in the middle is the workflow designer, and this is where you will build
your automation project.
You can add activities here by dragging them from the left pane or
they can be automagically generated for you by the recorder.
And here on the right is the properties pane, where you can see & change different parameters
and the settings of the selected activity.
Each activity has a different set of properties, and later in the training you will get to
know some of them.
But first let’s see how UiPath works, in a general sense.
It uses two ways of organizing the actions that it performs: flowcharts and sequences.
They control which action takes place and when.
This is what a flowchart looks like.
It works by executing each action, starting with the start node, and following the arrows.
Some special decision nodes can split the path it takes, in which case the execution
will follow only one of them.
They're easy to understand and follow, so they’re suitable for more complex workflows,
and higher level organization.
You'll get to create a flowchart in a minute, but let's also see its little sister, the
sequence.
As the name implies, it is a simple list of actions that we tell UiPath to take, one after
the other.
It's more appropriate for shorter, simpler workflows, or pieces of automation that we
can use in a larger project.
Generally, when starting a new automation workflow, you will first drag a flowchart
onto the main stage.
One important aspect of flowcharts and sequences is that – besides normal actions – you
can have any number of flowcharts and sequences, one inside the other.
This helps with organizing your project; you can review the high-level organization of
the workflow, or dive-in the nested flowcharts to see how it performs them.
For example, let’s say you are creating a workflow that reads incoming emails looking
for attachments, and when it finds them, uploads them to a dedicated FTP server.
It's a pretty complex project so you would break it into 3 parts: let’s say, a sequence
for reading email... a flowchart for finding emails with attachments... and another sequence
for uploading the file to FTP.
You could of course just as well do it with 3 sequences, or 3 flowcharts, or any other
combination.
It’s a very good idea to name your sequences and flowcharts with appropriate names.
We’ll call this one "read email", this one "find attachments" and this one "upload to FTP".
To make it into a functional workflow, we must connect the first sequence to the start
node, and also the rest of the actions; in the order we want them executed.
As you can see, it’s already starting to make sense.
And we’ll make a loop to repeat the process.
Now you would go into each container and start adding specific actions, or even other flowcharts
and sequences, but that is beyond the scope of this introductory tutorial.
-------------------- Because first, you need to know about variables
[_].
Even if you have no previous coding experience, you may already be familiar with variables
as they are used in mathematics – to represent unknown fields, or constants in an equation.
For instance, in the equation y = 5x + a, each alphabetic letter is a variable that
represents something that can have different values.
When X changes, Y changes too.
Being a mathematical formula, those letters generally represent numbers.
But UiPath – and coding in general – works with various types of data: numbers, text,
images, files, colors, and many others.
So it’s useful to think of variables like boxes that keep different types of data.
The data in the box might change but the box remains the same.
In one box you might hold an Excel table, and in another box you might hold a counter
for how many times a user has clicked something; and in another box – a text message to send
to your customers.
You get the idea.
Here are the main types of variables – or boxes – in UiPath; each for a specific type
of data.
Integer is for storing whole numbers, like 1,2,3 or 40million.
But it won't work with the decimal numbers, like 3.14.
There is another kind of box for that.
String variables can hold text of any kind, and you’ll usually see it in quotation marks.
And booleans can store a simple true or false value.
Generic is a special kind of variable, that can store almost any type of data.
we'll see in later trainings how that’s used.
And Array is a list of any type of data, as long as it is of the same kind.
You could have an array of integers, or strings, booleans, and so on.
Variables are easy to find in UiPath; they are at the bottom here, hidden by default.
When clicked, a list pops up showing the currently defined variables, which in our case is none.
To create a new variable, click here and type a name for it; we’ll just call it… myMessageToTheWorld.
Next we have to set what type of variable it is.
Since we want it to hold some text, we’ll just leave it as string.
The next step is optional, but let's also give this new variable a value; let's say
“what's up world!”; in quotations.
By the way, one very nice feature is the fact that if you rename a variable here, in the
variables pane, it will be renamed in all instances where it’s used.
You’ll appreciate it later in more complex workflows.
Anyway.
Scope is the other important property of variables and it represents where that variable is located
For example.
select the middle flowchart, named FindAttachments, and click on create variable once again; and
name this one Test.
You will notice that the scope of this second variable is now the flowchart FindAttachments.
You could say that the Test variable belongs to the find-attachments workflow.
And it will only be visible from inside that box, and not from outside.
You can see that by looking at the variables pane, and selecting either the FindAttachments
flowchart or the parent flowchart.
Now let’s see some real activities, not only these containers.
Delete these empty flowcharts and sequences, and drag in a message-box activity.
If you can't see it on the left pane, simply look for it using the search bar.
Connect it to the start by dragging from this little plug, to one belonging to the message
box activity.
Or, right-click on an activity box, and choose Set As start Node.
If this is your first contact with an activity, take your time to familiarize yourself with
its properties.
You can edit all of them, but we’ll just mess with caption and text for now.
Let's put “my first message box” for the
caption and “Hello world” as the text; both in quotations.
And let's run this super-duper workflow by going to the big, green, run button.
Or the smaller green run button.
By the way, you can hide the big buttons like in modern MS apps.
Great, we have our message box with the caption and the text.
Now let's switch it up a bit, and replace the current message, “hello world”,
with our previously created variable, myMessageToTheWorld.
so just select the text and type my…. and the rest of the name auto-completes.
So feel free to give your variables descriptive names, as it’s best to keep your workflows
tidy.
Now when we run the workflow again, we see that the message is actually the value of
the variable myMessageToTheWorld.
And if we change it to something else, and run again, the message
is updated.
And finally, the universal action, assign.
Like in a mathematical formula, it transfers
the value on the right to the variable on the left.
So if we want to change the contents of myMessageTotheWorld variable, we simply assign it a new value.
There's a bit more to this, because you can actually have expressions on the right, but
you'll see how that's used in the next tutorial.
I hope you now have a better understanding of how UiPath works.
Before you go let’s do a quick recap of what we covered in this tutorial, to make
sure we didn’t miss anything.
Along with basic programming concepts, you learned that UiPath automates various applications
by performing different actions – like click, type and many others – and It organizes
these actions into flowcharts and sequences.
Flowcharts are better for higher level organization, and sequences for shorter pieces of automation.
Then you learned about variables, the little “boxes” that hold information of different
types.
In the next training we will take these a step further, by setting up a few if/else
decisions and loops.
See you soon!