Git and Version Control in UiPath (Tutorial from Start to Finish)
Summary
TLDRIn 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
📚 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.
🛠 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.
🔄 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.
🤝 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.
🔍 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.
Mindmap
Keywords
💡UIPath
💡Version Control
💡Git
💡Repository Manager
💡Push
💡Pull
💡Conflicts
💡Branch
💡Merge
💡Commit
💡RPA Interview
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
関連動画をさらに表示
Save and work on Github for Javascript | chai aur #javascript
Day-11 | Git Interview Q&A and Commands for DevOps | Real World Example |#devops #github #git #2023
【Git入門講座 合併版】この動画1本でGitとGitHubの基礎をゼロからマスター!【初心者向け】
Day-9 | Git and GitHub | What is GIT ? | What is Version Control ? | #devops #2023 #github #gitlab
Realtime Powerful RAG Pipeline using Neo4j(Knowledge Graph Db) and Langchain #rag
Git and GitHub - 0 Experience to Professional in 1 Tutorial (Part 1)
5.0 / 5 (0 votes)