Git and Version Control in UiPath (Tutorial from Start to Finish)

Summary

In this educational video, Anna Jensen introduces viewers to version control using Git and UiPath. She explains the basics of backing up and collaborating on projects, demonstrates how to set up a Git repository, and guides through the process of committing, pushing, and pulling changes. Conflict resolution and branching strategies are also discussed, making it an informative resource for those interested in RPA development.

Takeaways

• 📚 Version control with Git and UiPath helps with backup and collaboration, essential for RPA interviews and tests.
• 🌐 Git online repository managers, like GitLab or GitHub, function as cloud storage for software development.
• 🔼 'Push' is the term for uploading projects to the Git repository, while 'Pull' is for downloading them.
• 💻 Setting up Git in UiPath is straightforward and integrated within UiPath Studio.
• 🧑‍🤝‍🧑 Collaborating with team members is easier with Git, ensuring everyone works with the latest project version.
• 🔄 Always work with the latest version from the Git repository to avoid conflicts and outdated instances.
• 📝 Descriptive commit messages are crucial for tracking changes and managing versions efficiently.
• 🌳 Creating branches allows parallel development without conflicts, which can later be merged into the main branch.
• ⚠️ Handling conflicts requires choosing the correct version to keep during a merge.
• 📢 Follow the instructor on Instagram for course updates, tips, and behind-the-scenes material.

Q & A

What is the main purpose of using version control in UIPath projects?

The main purpose of using version control in UIPath projects is to enable backup and collaboration. It allows developers to save different versions of a project, roll back to previous versions if needed, and work on the project collaboratively with other developers.

What is the term used for the online platform where the UIPath projects are backed up and shared?

The online platform where UIPath projects are backed up and shared is called a 'git repository manager', which functions similarly to a Dropbox or OneDrive but is specifically for software development.

What does the term 'push' mean in the context of Git?

'Push' in Git refers to the action of uploading your project changes to the remote repository, making them available to other developers or for backup purposes.

What does 'pull' mean when working with Git?

'Pull' in Git is the action of downloading or updating the project from the remote repository to your local machine, allowing you to work with the most recent version of the project.

How can conflicts be handled when working with Git?

Conflicts in Git can be handled by using 'pull rebase' to update the local project with changes from the main branch. Developers can then choose which changes to keep or merge, resolving any conflicts between different versions of the project.

What is the recommendation for developers when starting to modify a UIPath project?

The recommendation for developers is to always start by taking the project from the Git repository manager rather than working with an older local instance, ensuring that they are working with the most recent and backed-up version of the project.

What is the significance of writing descriptive commit messages in Git?

Writing descriptive commit messages in Git is important because it helps other developers or future you to understand what changes were made during each commit, making it easier to track the project's history and development progress.

How can multiple developers work on the same UIPath project without interfering with each other's work?

Multiple developers can work on the same UIPath project without interference by creating separate branches for their individual work. Once their work is complete and they are ready to integrate changes, they can merge their branches back into the main branch.

What is the process for creating a new branch in a UIPath project using Git?

To create a new branch in a UIPath project, a developer can go to the 'Manage Branches' section in Git, select the main branch, click the plus sign to create a new branch, and then name the branch appropriately. After that, they can start working on their own branch without affecting the main branch.

How can a developer merge their work from a branch back into the main branch in Git?

To merge work from a branch back into the main branch, a developer should first ensure all changes are saved and committed. Then, they can go to the 'Manage Branches' section, select the main branch, find their branch, right-click it, and choose 'Merge'. After resolving any conflicts that may arise, they can push the changes to update the main branch.

What is the importance of branches in Git for collaborative project development?

Branches in Git are important for collaborative project development as they allow multiple developers to work on different features or fixes simultaneously without causing conflicts in the main codebase. This enables parallel development and efficient merging of changes once the work is completed.

Outlines

00:00

📚 Introduction to Version Control with Git in UiPath

Anna Jensen introduces the concept of version control in the context of UiPath development. She emphasizes the importance of backing up projects and collaborating with other developers using version control systems like Git. The video aims to demystify Git, explaining it as a tool for backup and collaboration, and mentions that it is a common topic in RPA interviews. Key terms like 'git online repository manager', 'push', and 'pull' are introduced, and the video promises to guide viewers through setting up Git with UiPath and handling conflicts.

05:01

🛠 Setting Up Git with UiPath Studio

This section provides a step-by-step guide on setting up a Git repository using GitLab, which serves as the online storage for project files. The process includes creating a new project in GitLab, naming it, choosing privacy settings, and deciding whether to include a README file. The video demonstrates how to clone the repository URL and create a new project in UiPath Studio, illustrating the initial commit process and the importance of pushing changes to the remote repository for backup and collaboration.

10:01

🔄 Committing and Pushing Changes in Git

Anna explains the process of committing changes locally and then pushing them to the Git repository to make them available remotely. She details the steps to commit changes in UiPath Studio, including writing descriptive commit messages for clarity in version tracking. The video also covers the use of the 'push' function to upload committed changes to the remote repository and the importance of starting with the most recent version of the project from the repository to avoid conflicts.

15:02

🤝 Collaborative Development with Git

The script discusses collaborative development using Git, where multiple developers can work on the same project without being physically present. It shows how to clone a remote repository to start working on a project and the importance of committing and pushing changes regularly. The video also touches on the potential for conflicts when different developers modify the same part of a project and introduces the concept of 'pull rebase' to update local projects with changes from the main branch.

20:05

🔍 Resolving Conflicts and Branching in Git

This part of the script delves into conflict resolution when two developers make different changes to the same part of a project. It demonstrates how to use 'pull rebase' to bring the latest changes from the main branch into a local branch, compare versions, and decide which changes to keep. The video introduces branching as a way to work on different features simultaneously without affecting the main workflow, and it shows how to merge these branches back into the main project after development is complete.

🔄 Merging Changes and Final Thoughts on Version Control

The final paragraph covers the process of merging changes from a feature branch back into the main branch. It illustrates the potential for conflicts during the merge and how to resolve them by choosing which changes to keep. The video concludes with a reminder of the importance of using version control for project management and collaboration, and it invites viewers to follow Anna on Instagram for updates on her courses and additional tips.

Keywords

💡UIPath

UIPath is an RPA (Robotic Process Automation) software platform that allows the creation of software robots to automate repetitive tasks. In the video, UIPath is the central tool discussed for automating processes, and the script explains how to integrate it with version control systems for better project management and collaboration.

💡Version Control

Version control is a system that records changes to a file or set of files over time so that developers can recall specific versions later. The video emphasizes the importance of version control in RPA projects, using Git as an example, to ensure backup, collaboration, and the ability to revert to previous versions when necessary.

💡Git

Git is a widely used distributed version control system designed to handle everything from small to very large projects with speed and efficiency. The script introduces Git as a key component for managing UIPath projects, allowing for backup and collaboration among developers.

💡Repository Manager

A repository manager is a system that stores and manages access to versions of digital assets or code in a repository. In the context of the video, the repository manager, such as GitLab or GitHub, is where the UIPath projects are backed up and from where developers can pull and push changes.

💡Push

In version control, 'push' refers to the action of uploading local changes to a remote repository. The script explains that when changes are made in a UIPath project, they are 'pushed' to the Git repository to update the remote version of the project.

💡Pull

'Pull' is the action of downloading the latest changes from a remote repository to a local copy. The video script mentions 'pull' in the context of updating a local UIPath project with the most recent changes from the Git repository.

💡Conflicts

Conflicts in version control occur when changes made by different developers affect the same part of a file. The script discusses how to handle conflicts when they arise, such as when two developers alter the same activity in a UIPath project.

💡Branch

A branch in version control is a separate line of development that diverges from the main branch. The video script explains how to create and work with branches in Git to allow developers to work on different features or fixes without affecting the main project until they are ready to merge.

💡Merge

Merging is the process of integrating changes from one branch into another. The script describes how to merge a developer's branch back into the main branch after completing work, which involves resolving any conflicts and then updating the main branch with the new changes.

💡Commit

A commit in version control is a snapshot of the changes made to the code. The video script uses the term 'commit' to describe the process of saving changes locally in the Git system, which can then be pushed to the remote repository.

💡RPA Interview

An RPA interview refers to a job interview for a position related to Robotic Process Automation. The script mentions that knowledge of version control, Git, and UIPath is often required in such interviews, indicating the importance of these concepts in the field of RPA.

Highlights

Introduction to version control in UIPath projects for backup and collaboration.

Explanation of key terms in Git such as 'online repository manager', 'push', and 'pull'.

Demonstration of setting up a Git repository using GitLab.

Creating a new UIPath project and preparing it for Git integration.

Initiating a Git repository in UIPath Studio and committing changes.

The process of pushing changes to a Git repository in GitLab.

Importance of always updating from the Git repository manager instead of working locally.

Making changes to a project and committing them with descriptive messages.

How to handle conflicts when multiple developers work on the same project.

Using 'pull rebase' to update a project with changes from the main branch.

Creating and working with branches in Git to avoid conflicts.

Merging branches back into the main branch after completing work.

The significance of writing descriptive commit messages for better version control.

Recommendation to always pull the latest version from the Git repository before starting work.

Instructions on how to clone a remote repository in UIPath Studio.

The concept of branches allowing developers to work in parallel without affecting the main workflow.

Final thoughts on the importance of version control in collaborative RPA development.

Transcripts

my name is anna jensen let's learn some

uipath

today we will talk about version control

git and uipath it sounds very advanced

and it's something that is often asked

about in rpa interview and tests

but really all there is to it is backup

and collaboration

we can backup our uipath project and our

fellow developers can take down these

projects and work with them it could

also be yourself so you know that you

always have your project backed up and

you can have different versions so you

can roll one version back two versions

back or whatever you want

really really smart

some key words in git is that we have

our git online repository manager that

was the one where we backed up our

project to and we taken down that's like

a dropbox or onedrive for software

development

then when we upload our project we call

it push

when we take down these project i could

be our fellow developers or ourselves we

pull down these things

that's it in this video we will talk

about how to set it up it's really easy

it's integrated in uipath we will also

talk about how to work in parallel and

handle conflicts and make sure you

follow my instagram because i'll post

all my courses there you'll get notified

when i make a new course which of course

they are free and you will get behind

the scenes material and tips and tricks

so find me on instagram now let's learn

about git first of all we need a git

repository manager that's where our

files will be stored so when we work on

the files locally and upload them it

will be stored here so across different

teams it will they will use this

platform

i will use gitlab for this project but

you can use github or any other git

online repository manager it will look

the same and the intuition will also be

the same so if you sign up with gitlab

choose new project click here

we choose create blank project so this

will just create a bland blank project

repository we give it a name i will call

it open website unders

you can place it in a different folder

or

a online place here at this site we will

just call it the same that will almost

always be the

go-to solution we could give it a

description that is optional we won't we

can choose between private or public

i will just choose private do we want it

read me probably not oils we will add it

later on so i'll just create a project

it will look like this we will have some

initial things that we can

do

this address here we will use that you

can find it here that is the address of

this repository you can find it down

here or you can click clone

clone with https and copy it from here

so let's create a project in studio

uipath studio and push it to this git

repository so i open up uipath it will

look like this we will just create a

blank project so click here

give it a descripting name i'll just say

open

website unders

and then we'll click create

we will open the main workflow

this is really not important what we put

in here because we will just see how we

back up and how we do changes but let's

go to activities and find an open

browser

here and drag it in

here we can open a url so in quotation

marks we can type anasyansen.org

this will open up my web page

so we save it

now we want to have this project backed

up in our git repository that's over

here

remember this

so what we do here is that we click home

we click team

we choose git init this will create a

git hierarchy in our project folder the

uipath folder so click here

we will choose the folder in the uipath

of this current project uipath will

automatically

suggest this so just click select folder

like this here we can see where we have

made some changes this is the initial

we did we changed the main so we go down

here and we give it a message we can say

initial

commit

and then we can see that we have some

options we can of course click cancel

that will just cancel this

but we want to commit it and push it

commit that is just when we save it

locally

and when we push that means upload to

the git repository here in gitlab so if

i just

choose commit it will save it locally

but we want it up here so we click

commit and push

like here let me drag this down we want

to give it a name this is not important

but we will use it in here in manage

remote so it can just be open where

unders then we want the url and as i

showed you you can find it down here and

if this is not visible just click the

drop down clone clone with

https

copy it from here

go back to studio and manage remote

here we paste in the url like here we

click add

now we click save

and we have to use the credentials these

are not

project level credentials that is the

credentials of your git instance here

it's my gitlab so i'll put in my user

and then i'll put in my password

like this so now we have pushed it that

is uploaded it to the git repository if

we go back to our git repository manager

gitlab then we'll click refresh we can

see that our project will be down here

isn't it nice so now another team member

can take this project and work on it or

with the future you can work with it

my recommendation and this is very

important is that you will always when

you start to modify a project always

take it from this git repository manager

never work with it locally of course if

you just worked with it for 10 minutes

ago do it here but if you if it was like

one week or two weeks since you last

modified

take this from the git repository

manager because then you'll know that

this is always the last backed up

project

so then we won't work with an older

instance that would be in our local one

so here we have this

sequence

now we want to make a little change to

the sequence so we find a message box

scroll a little bit down and drag it in

like this

so we will just say

hello viewer

you are awesome

like this and we'll save it

remember that now remember notice that

down here the status part is say zero

zero but when we click save something

will happen now that we can see that we

have one change and this is this change

so if we click down here

we can see that we can commit right from

here another place to commit is that if

i click cancel here if i go to project i

can right click here and click commit

usually i will use the status bar down

here

so let's just click here and we can say

that this one is

message box

added then we will click commit and push

and you will see that this one down here

will change to a zero in a bit

right there right here but say that we

only have saved it locally that is if we

only have committed it let me add a

space after awesome nothing really

special we click save

now we have this change here so i click

it

then we can say space added to message

box another good tip is to always

write descripting commit messages

because then when we do version control

say that we have like 10 different

versions that we have committed to our

git repository it will be easy to see

what has changed for other developers or

the future you

but now we only save it locally so we

click commit

and what happens here is that this one

gets zero because we have no changes we

haven't commit but we can see that we

haven't pushed anything so we are one

ahead it's called that is we have worked

one change ahead of the

remote repository version which is the

one over here so to fix this if we want

to make sure that this one is pushed we

just can click here

pushing changes and we are all even

and in case you wonder what these two

things are here this is just our

repository name and the slug in the open

website on this and here we can see what

brands we work on

we will get back to that in a few

seconds

because now and now things get really

smart

say that another developer in the

company wants to change this project

and usually two developers don't use the

same computer they might sit in

different countries so we open up

another uipath instance simply just

click the ui pass studio

and i put it up here in the corner that

was our initial uipath while the other

one's open while it's open i can

maybe ask you to help me if this video

helps you then please give it a thumbs

up that will really help my channel and

the reach of my videos thank you

so now i can move it down here

and instead of just creating a new

project we can clone the remote

repository which is this one so let me

go back to the new one so when we open

up your path studio click clone or check

out here

we can clone repository so we click here

and again we need a url and in case we

have forgotten it we can find it

here clone clone with

https

that was difficult to say so i put it in

here we can choose a check out directory

but this one will probably be taken from

the previous project here so let's just

call it depth b

again we use the local directories like

this c colon like here to develop in but

when we finish develop for that day or

whatever we push it to

the remote repository and the next time

we will work on it we just take it from

the git remote repository instead of the

local ones in that way we make sure that

we always have the updated version i

know i repeat myself but this is

important

then we click

then we click use credentials

we will type in our credentials

and click open

so now

developer b he

will open the project and can work on it

so that's quite clever we can easily say

share uipath project between developers

and let me open up the main here

and you can see that we or at least in a

second we will just have the project

that we just created

so let me widen it a bit so we can see

it

so here it is now let's say that we will

change it a bit more

you can just uh that b wants to add to

this project so he go into the message

box and say you are very awesome let me

have space like this

then we just click save

and to commit and push it to the remote

repository we click the commit change

here

then we can say

defeat

added very to message box

again choose a very describing message

click commit and push

so now that we have worked on the

project and say that dev a that's this

guy up here he wants to have their these

updates you can see here we just have

you are awesome that was the old one and

here we have you are very awesome to do

this we can click down this main here

and we can click pull rebase pull rebase

will

take whatever is in the main and make

sure that we get it here so we click

here pull rebase

boom

now we have updated our project so these

two guys can work with each other but

say that

we both work on the same activity we

both want to update the message box both

death a up here and death b down here so

look what's happened so say that

death a up here hello a handsome viewer

like this

and

death b he might want to delete the

space so delete the space

now we have two different

activities in the same so look what's

happening so we save it up here we save

it down here we in order to commit

something we always need to save it

that's why that's when they will show up

here as changes

so let's say that we first

push this one down here from def b

nothing will really happen because

there's no conflict yet

so here we

deleted a space in

message box

so i commit and push

then if we go up here to death a

you see now we have conflict and

let me show you what's happening so here

we

added handsome

we commit and push

and now we have a conflict so we want to

pull we want to have whatsoever in the

main branch so we click pull rebase

and now we will have a look at what's

going on

here we can see the two different

versions

we have this the left one that is the

remote you can see it up here that is

the one from dev b he pushed that's this

one

and this one is the local that's the one

we're working at that's this this one up

here we can see that this one is yellow

that is the message box if we highlight

this we can see what's happening in the

properties over here we have the

properties that is just the text hello

viewer you are handsome that was this

guy and here we have hello handsome

viewer you are very awesome that is this

one here

now we have to choose which one of these

two versions we want to keep

and i mean right here it doesn't maybe

it's not that important because this

just works but it could imagine it could

be a bigger project so be careful what

you do here if you do it like this so we

can either choose the left that will be

the remote to keep or we can choose the

right that will be the local that will

now be the main uh rip in the remote

repository sorry

so i choose to write

that is this hello handsome viewer you

are very awesome so i click save

now we push the changes so now the main

will get changed again because we chose

this one as the

version we want to keep so if we go down

here again we can now pull rebase again

and you will see that this hello

handsome viewer will be added here

a cool thing to do if we want to work in

parallel which we often want is to

create a branch a branch is simply just

what it says a branch of the main

workflow we can work there without

having any conflicts with the other

developers and then we when we are ready

to push it to the main to merge it

actually then we will just do so

let me show you how it work say that def

b you can see he's working on the main

but let's create a branch he can work on

so we click the drop down here we click

manage branches here we can see our

brands here we have the main branch so

if we mark this

then i click the plus sign here and i

could call this def b's work like this

and then we click create branch from

main and we can see that it has now been

created

so then i click save

of course the branch is now

looking exactly like the branch

the main branch but if we want to work

with it click the drop down here and you

can see that it now appear up here that

these work

like this

so let's change a bit we can just

change all the things that we wrote here

we do this

then we click save so now we have

changed this message box we can see the

commit changes down here and let's maybe

add a right line

so let's search for a right line or find

it here in favorites just choose search

if you do not have any editing favorites

here and i'll just add in the right line

here

so what i can do here is that i can in

quotation marks tell

people here

please

like the video

if it helps you and again i know i said

it twice in this video this will really

help me a lot if you simply just click

like on the video it will help the

channel

so now we have these things here i click

save again

and i could of course push it to the

deathbeats work the branch so if we do

that we can commit message we can say

add right

line and i know we did some other things

but we'll just click commit and push

so now this work

has been pushed into the branches here

we can even go to our

repository

and if we click repository we can click

branches we can now see that we have our

depth b

branch of this one here so we have the

main branch that is the default and then

we have depth b's work so let me go back

to our project

like here then we go to uipath studio so

this was staff a let me open fb it's

here now say that we want to merge we

have worked a whole day or maybe two

days

we want to merge this one

into our main and let's say that dev a

also worked a bit on this so he probably

just deleted everything so quotation

marks and he just say hey like this so

they both change it we will just push

this one as well

a lot of push

hey add it commit and push

so if we go back to def b now we want to

merge this into the main how do we do

that well make sure you have save it and

committed and pushed all changes like

here so we click the drop down then we

go to main

that was the old

one before we changed anything and now

you

can click manage branches

here

you can see the current branch should be

main so make sure it's the main and not

death beast work or whatever you call

yours

then go down to death b's work right

click click merge

like this and then we can just push it

so we click here

we push it and we can see that the

current branch is out of date we

expected that because we have updated it

up here so i click pull rebase

and now we can see the conflicts and

here we can it is really smart because

now we can choose which one we want to

keep

so do i want the one with right line

or do i want the one where the message

box say hey well i want the one with the

hello handsome viewer and right line so

i click save here

like this

so now our

deathbeats work have now been merged

into the main so if this guy up here the

dev a

he will pull rebase

you will see that he will have this

hello handsome viewer and he will have

the right line

i'm working on a full uipath version

control course to make sure you will get

notified when it's here simply just

follow my instagram where i will post

all news about my courses and i'll post

tips and tricks

you