ROS Simplified: ROS 2 Tutorial for Beginners

ROS2 Tutorial for Beginners (Part 7) Is Out — Creating a Publisher and Exploring It with ROS 2 CLI

Satyarth Shree — Thu, 30 Apr 2026 05:11:48 GMT

In previous part we discussed what are topics, publishers and subscribers. We also started writing code of our publisher but didn’t complete it fully.

In this part I have discussed how to write the code of a publisher node completely and then how to run our publisher and check whether it is properly running or not.

This part has been posted on my medium account.

Click on the button below to read it.

Part 8 will be released within next 10 days (by 9th May 2026).

Till then stay tuned and keep learning!!

ROS 2 Tutorial for Beginners (Part 7)

ROS2 Tutorial for Beginners (Part 6) Is Out - Learning Topic and Publisher Nodes

Satyarth Shree — Wed, 15 Apr 2026 05:36:58 GMT

The 6th part of the ROS2 Tutorial Series, titled
“ROS2 Tutorial for Beginners (Part 6): Topics and Publisher Foundations”, is now live.

For those who are new here, ROS Simplified is where I share beginner-friendly tutorials on ROS 2.

In the previous parts, we focused mainly on core basics, but didn’t go deep into how communication between ROS 2 nodes actually works.

In this part, I’ve started breaking down the publisher–subscriber system, which is one of the most fundamental communication mechanisms in ROS 2.

This article is published on my Medium account.

Click below to read it 👇

ROS 2 Tutorial for Beginners (Part 6)

Stay Tuned - more tutorials coming soon!

ROS2 Tutorial for Beginners (Part 5) Is Out — Managing Workspace Storage

Satyarth Shree — Thu, 26 Mar 2026 13:18:11 GMT

The 5th part of the ROS2 Tutorial Series, titled
“ROS2 Tutorial for Beginners (Part 5): Managing ROS2 Workspace Storage Using Linux Commands”, is now live.

For those who are new here, ROS Simplified is a publication where I share beginner-friendly tutorials for ROS 2.

In the previous parts, we focused on core ROS2 concepts. In this part, I’ve covered something slightly different — not directly a ROS concept, but something that becomes really useful when you start working with multiple ROS2 workspaces.

This is something I personally found useful while managing my own workspace.

This part has been published on my Medium account.

Click on the button below to read it.

ROS2 Tutorial for Beginners (Part 5)

ROS2 Tutorial for Beginners (Part 4) Is Out — Understanding rclpy.spin()

Satyarth Shree — Fri, 13 Mar 2026 11:29:57 GMT

For those who don’t know, ROS Simplified is a publication where I share beginner-friendly tutorials for ROS 2.

The 4th part of the tutorial series, titled “ROS2 Tutorial for Beginners (Part 4): Understanding rclpy.spin()”, is now live.

As you already know, in the first three parts we covered some fundamental topics such as:

Creating a workspace
Creating a package
Creating a node
Tools like rqt_graph
Commands like ros2 node list

In Part 4, I discuss the spin() function in ROS 2, since it forms an important foundation for understanding different types of callbacks that we will explore later in the series.

This part hasn’t been posted on Substack. Instead, it has been published on my Medium account.

Click on the button below to read it.

ROS2 Tutorial for Beginners (Part 4)

ROS 2 Tutorial for Beginners (Part 3): Understanding ROS 2 Nodes (Sub Part 2)

Satyarth Shree — Mon, 02 Feb 2026 13:24:33 GMT

About This Article

This article is the sequel of ROS 2 Tutorial for Beginners (Part 3): Understanding ROS 2 Nodes (Sub Part 1). Therefore it is necessary to read the sub part 1 before continuing to read this tutorial. Click below to read it.

In the previous part of this ROS 2 Tutorial series we discussed how we can run built-in nodes and how can we introspect them using various tools provided by ROS.

In this part we will discuss how can we run our own custom made nodes. Most importantly what are the correct set of procedures that a ROS 2 learner needs to follow to run his own made nodes.
This is exactly what we will be discussing in this tutorial.

In this tutorial I will use a basic node which I created in the part 2 of this tutorial series. If you are aware how to create a node that displays a message then you can proceed with this part but if you aren’t then I recommend that you should first read part 2 before continuing with this one. Press the button given below to read it.

ROS 2 Tutorial for Beginners (Part 2)

If you wish you can continue reading this part without going through part 2 as every tutorial I write is meant to be a standalone article but to gain 100% understanding it is recommended that you go through it once.

We will be using a node that we created in part 2 of this tutorial series. To install that node in your system go to this github repository:

https://github.com/Satyarth-Shree/ros2-beginner-part-2-python-node

and then follow the instructions written in the README.md file to get this node installed in your system.

We will run this node later on in this blog so it is recommended to install it in your system so that you can also take advantage of a hands on practice session while reading this blog.

Alright let’s continue

Section 1: Steps to Run a Custom Node

By custom node I mean to say a node that you have created yourself. Running a basic custom node requires you to execute four main steps. They are explained in the exact order in which they needs to be executed below.

Step 1: Creating a Node

The first step before trying to run a node is obviously creating it first. After creating a node you have to create an executable out of it. This is one of the most crucial step and the one where most people make a mistake.

In part 2 we have done exactly this.

Move to step 2 only after your node is correctly setup.

Step 2: Sourcing ROS 2 Environment

After your node has been successfully created and saved it is recommended to source your ROS 2 environment again. To do this type the following command:

source /opt/ros//setup.bash

Replace by your ROS 2 distribution. If you are using ROS 2 humble distribution then write the following command to source your ROS 2 environment:

source /opt/ros/humble/setup.bash

If you are using ROS 2 Jazzy distribution then write the following command:

source /opt/ros/jazzy/setup.bash

Running this command ensures that ROS 2 functionalities can be used.

Step 3: Sourcing Your ROS 2 Workspace

Important Note: Clone the repository that I have shared previously before continuing further.

A node is always created inside a package and a package always exists inside a workspace. After running colcon build, our package and node executables are installed in the install folder. So we now have to run the following command:

source ~//install/setup.bash

Replace by the name of your workspace inside which you have created your node.

This command updates our ROS 2 environment so that ROS 2 can locate and run our node. The name of my workspace is “ws” so I will write the following command:

source ~/ws/install/setup.bash

This is the same workspace inside which my node that I created in part 2 exists. I have already shared the link of my github repository and also the instructions on how to get this node working on your system (in the README.md file). Read those instructions carefully.

Let’s assume you have created a folder named “ws_1” inside which you have cloned this repo. So now type the following command:

cd ~/ws_1/

This will ensure that you are currently in the folder inside which you have cloned the repository. Now run the following command:

colcon build

This will build your workspace. Now run the following command:

source ~/ws_1/install/setup.bash

Replace “ws_1” by the name of your workspace. Your workspace is the folder inside which you have cloned the github repository that I have shared with you.

Step 4: Running Your Node

To run a node you have to type a command having the following syntax:

ros2 run

After run you have to first write the name of the package inside which your node exists and the name of the executable that will run your node. Remove greater than and less than signs while writing actual commands. They are only used to write syntax.

Now run the following command:

ros2 run py_pkg my_node

and you will see a output like this being displayed:

[INFO] [1768188057.615481153] [python_node]: I am learning ROS 2.

It is necessary to source your workspace before trying to run your node that you have created. Whenever you run “colcon build” after creating a node your executables are basically installed in the install folder of your workspace so it becomes necessary to source it.

Since you have cloned my github repository so the name of package and executable will be the same.

Section 2: Errors You are Possibly Getting

Maybe you are not getting this output and you are getting some error instead. This can happen because of two possibilities.

Error No.1: Running colcon build from the wrong folder

I asked you to run colcon build from the folder inside which you have cloned my github repository. If you ran colcon build while being inside src folder or some other folder apart, then your workspace hasn’t been properly created yet. Make sure that the folder inside which you have cloned your repository has the following four folders in it:

1. build
2. install
3. log
4. src

The src folder is the one which you cloned from my github repository while the rest three folders are the ones which are automatically generated when you run colcon build.

If your folder doesn’t has this folder structure then you have run colcon build from the wrong place/folder.

But there is nothing to worry. This mistake is recoverable. Just go to that wrong directory where you have ran colcon build using the “cd” command and type the following command:

rm -rf build install log

This command will delete build, install and log folders from that directory. Now go to your workspace using the “cd” command and make sure you are at the correct folder before running “colcon build”. Right now inside that folder you will only see one folder which is src because you have used “colcon build” in some other folder so build, install and log folders haven’t been generated yet in your main workspace.

Now when you are in your workspace folder inside which your src folder is present run the command:

colcon build

To successfully generate your workspace. Let’s assume that you have cloned my github repository in a folder named “ws_1” so execute the commands given below one by one in the exact same chronological order:

1. cd ~/ws_1/
2. colcon build
3. source install/setup.bash

Now type the following command to run your node:

ros2 run py_pkg my_node

It will most probably run now. If you are still encountering some errors then make sure you have followed all the steps currently in this section and then proceed to the next one where we are discussing about some another error.

Error No.2: Not Sourcing Your Workspace

It is possible that your workspace is correctly configured but you are still not able to get your node running. If after typing the following command:

ros2 run py_pkg my_node

you are getting the following error:

Package 'py_pkg' not found

Then it is certain that you are doing this mistake.

You are getting this error because ROS 2 cannot identify or locate your package. This happens when you haven’t sourced your workspace correctly.

Let’s assume that the name of your workspace is “ws_1”. So run the following command first:

source ~/ws_1/install/setup.bash

Replace ws_1 by the name of your workspace. After running this command now again run the the following command:

ros2 run py_pkg my_node

Doing this will completely fix the “package not found” error. I also did exactly this as shown in the figure below:

As you can see in the figure shared above, I was getting the “package not found” error by then I sourced my workspace and the error was resolved. The name of my workspace is “ws”, so I replaced “ws_1” by “ws”. You have to also do the same. Replace “ws_1” by the name of your workspace.

This was a short tutorial which is basically aimed at explaining how you can run your own made nodes. In previous part I discussed on how you can run multiple nodes together and how you can introspect them. These concepts are very important for developing an understanding of nodes so make sure to read them too.

What’s Next

We have covered the following concepts so far in our tutorial series:

Creating a Workspace
Creating a Package
Creating your own custom node that displays a message
Running Built In Nodes
Running Custom Nodes

Edit:
The next part which is Part 4 of our ROS 2 Tutorial series has been released. Click here to read it:

ROS 2 Tutorial for Beginners (Part 4)

About The Publication: ROS Simplified

ROS Simplified is a learner-driven publication dedicated to making ROS (Robot Operating System) concepts clear, practical, and accessible. We provide tutorials, conceptual explainers, and project walkthroughs designed to help students, hobbyists, and engineers understand and apply ROS efficiently.

This is one of my initiatives to contribute helpful content to the ROS community. If you also have some experience with ROS and want to become a writer then visit the publication’s page and go to Become a Contributor tab to apply and get added as a contributor of this publication.

If the content provided by our publication is helping you to learn more about ROS 2 and you want to keep receiving this content then do subscribe our publication so that you can directly receive our articles in your inbox.

- From Satyarth Shree, Founder and Editor-In-Chief of ROS Simplified

About The Author

Hi, I am Satyarth Shree a first semester BTech Robotics and Automation student at Lovely Professional University (LPU), India. I am an aspiring robotics engineer who is publicly documenting his learning journey using platforms like medium and substack. My areas of interests include ROS, python and mathematics. Currently I am focusing on ROS more. I have also started a publication named ROS Simplified to make ROS accessible to everyone by providing beginner friendly tutorials free of cost.

Let’s Connect

My Github: https://github.com/Satyarth-Shree
My LinkedIn: https://www.linkedin.com/in/satyarth-shree-761357374/
My CodeWars: https://www.codewars.com/users/Satyarth-Shree
My X: https://x.com/BuildUnderdog
My Hashnode: https://hashnode.com/@SatyarthShree
My Portfolio: https://satyarth-shree.github.io/My-Portfolio/
To professionally contact me for internships, collaborations or similar opportunities click here: https://forms.gle/SH9bj1oJwqPtJtD26

ROS 2 Tutorial for Beginners (Part 3): Understanding ROS 2 Nodes (Sub Part 1)

Satyarth Shree — Sun, 04 Jan 2026 13:53:04 GMT

About This Article

This tutorial has been written for beginners who wish to practically understand what a ROS 2 node is and how does it works.

If you are someone who wants to see nodes in action and how they work with each other then you have came to the right place.

I will not talk about any bookish definitions. I will show you how a node works and how you can analyze a node while it is working.

I also recommend you to do what I am doing step by step. Open this blog and your terminal simultaneously and follow what I am going to show you to extract maximum value from this tutorial.

This tutorial is a hands on practical guide so I will show you the working of a node and how it interacts with other nodes practically.

If you haven’t installed ROS then read part 1 of this tutorial series first.

ROS 2 Tutorial for Beginners (Part 1)

This is the third part of our ROS 2 Tutorial for Beginners Series and a continuation of the second part. If you are interested then you can read part 2 also.

ROS 2 Tutorial for Beginners (Part 2)

So let’s get started

Section 1: Set Your System for a Smoother Workflow

In later sections of this blog when we will run multiple nodes together you will have to open multiple terminals together.

While you can open multiple terminals using the terminal which is pre installed on your Linux system but I recommend using another command line interface known as terminator. In terminator you can split your terminal into multiple terminals without even touching your mouse therefore increasing speed and easiness to navigate and use command line.

To install terminator follow the steps given below:

Connect your system to an active internet connection
Open your terminal
Type the following command: sudo apt install terminator

After you type this command installation of terminator will start. It is a very lightweight command line interface so it won’t take much of your memory and will be installed quickly. Once installation is finished go to your apps section and open terminator. You will see the following interface:

Now click on CLI (Command Line Interface) and press Ctrl + Shift + E and you will see that your terminator has been vertically split into two parts as shown in figure below:

By Ctrl + Shift + E, I meant to say that press Ctrl, Shift and E simultaneously on your keyboard.
Now click on any one of these parts and press Ctrl + Shift + O and you will see that the part which you have clicked will further split into two horizontal parts as shown in figure below:

Now do the same with the part that is left.

Click on it once to select that part
Press Ctrl + Shift + O

And you will see that now you have four different command line windows in which you can type and run commands as shown in the figure below:

Now click on any one of these 4 parts to select that part and then press Ctrl + Shift + W. You will notice that doing this will destroy that part and your terminal will now look somewhat like this:

Now again click on one part and press Ctrl + Shift + W. Another part will be destroyed and your terminator will look somewhat like this:

When you open a terminator you will see a single command line interface (CLI). These commands can allow you to create multiple CLI and then destroy them if you don’t need them.

To summarize:

Click a CLI to select it and then press
1. Ctrl + Shift + E to split vertically
2. Ctrl + Shift + O to split horizontally
3. Ctrl + Shift + W to destroy that selected CLI window
Each part after splitting can be called a window of the Command Line Interface (CLI) which is our terminator.

Although installing terminator is not mandatory but it will help you increase your efficiency once you get a knack of it so I recommend using it.

Section 2: Running a Node

Now let’s run a node. Before running a node you should know how you can run a node. To run a node you have to run a command having the following syntax:

ros2 run

A node is always created inside a package so to run a node you have to write the name of the package inside which your node exists. After you have created your node you have to create an executable to run that node. So after writing package name you have to write the name of your executable. Do not write greater than (>) or less than (<) signs when trying to run a node. These are just used while writing syntax.

The name of your executable and the name of your node may or may not be same so don’t get confused.

To simplify you can say there are two types of nodes in ROS 2. They are:

Built - In Nodes: These are nodes which are already installed when you install ROS 2. So they can be considered as built-in or pre installed nodes.
Custom Nodes: These are the nodes that you create yourself.

There is a small change in the procedure to run Built - In and Custom Nodes which we will discover in subsequent sections of this blog.

First we will discuss how to run a built - in node by running a few of them.

Running a Built - In Node

The first step before running a ROS 2 command is to source ROS 2. To source ROS 2 type the following command:

source /opt/ros//setup.bash

Replace by your ROS 2 distribution. If you are using humble then you should execute the following command:

source /opt/ros/humble/setup.bash

If you are using Jazzy then you should write:

source /opt/ros/jazzy/setup.bash

Simply replace by your ROS 2 distribution as shown above.

We are going to run a built-in node which publishes messages. To do so after sourcing your ROS 2 environment split your terminator CLI into four windows (as already discussed above) and run the following command in one of those windows:

ros2 run demo_nodes_cpp talker

You will start seeing a series of “Hello World” messages getting displayed as shown in the figure below:

These messages will keep on displaying again and again until you terminate this node. Now take a closer look at the command which you used to start this node. It is:

ros2 run demo_nodes_cpp talker

As I earlier told you that after ros2 run we write the name of the package inside which our node exists and then the name of our executable. So in this case the name of our package is demo_nodes_cpp and the name of our executable is talker.

Alright so now one of our nodes is already running on our system. But how can we check which node is running. There are essentially two methods to do so.

Method 1: Using ros2 node list command

While your node is running click on another CLI window (one of parts that you have generated after splitting your terminator) and type the following command:

ros2 node list

Then you will see the name of the node which is currently running as show in the figure given below:

As you can see in one of the CLI window our node is running and in another CLI window when we typed “ros2 node list” then the name of the node that is running which is talker was displayed.

Now click on the CLI where your node is running to select it and press Ctrl + C. This key will stop your node as shown in the figure below:

Now again type ros2 node list in another terminal and you will see that no name is being displayed as shown in the figure below:

As you can see after you terminated your node by pressing “Ctrl + C” and then ran the command “ros2 node list” no node was displayed because now no node is running.

So we can conclude that the command: “ros2 node list” displays the names of those nodes which are currently running.

There is a another method to check which nodes are running.

Method 2: Using rqt_graph

Again run the node by typing the following command in one of the terminals:

ros2 run demo_nodes_cpp talker

Now in another terminal type the following command:

rqt_graph

And following screen will open before you:

On top left corner you can see a refresh icon written just below Node Graph. The icon looks like this:

Click on this icon once to refresh rqt_graph and you will see the following node in the graph:

rqt_graph is basically a tool which you can use to see the name of the node which is currently running visually. As you can see the name “/talker” is displayed which is the same name that was displayed when we executed “ros2 node list” when we were discussing about the first method.

Now close this graph by clicking on the cross icon on the top right corner and terminate your node by clicking on the terminal where it is running and then pressing “Ctrl + C”.

Now after terminating your node if you again run rqt_graph and refresh the graph then you will not see the name of any node because no node is running.

These are two methods using which you can check which node is running. These methods can also be used for Custom nodes.

Section 3: Experimenting With Nodes

You can achieve fluency in ROS only if you intentionally try to break things and then fix them. Most people especially beginners think of their terminal as a black box in which they run a command and then wait for it to magically run without any errors.
What I want to say is that many beginners have a fear of terminals and commands because they don’t understand the logic behind the system they are using.

If you truly want to broaden your understanding then read some of the experiments which I did and what insights and concepts that I learned side by side while doing them. You are more than welcome if you want to try these experiments yourself as I will be talking about them in great detail.

Experiment No.1: Running a node more than once

Open your terminator and split it into 4 parts. In two terminals run the talker node that we ran in previous sections of this blog by typing the following command:

ros2 run demo_nodes_cpp talker

Your terminal will look like this:

This talker node is running in two terminals. Now in the third terminal run the command:

ros2 node list

and you will see a warning message being displayed as shown:

The warning states that:

WARNING: Be aware that there are nodes in the graph that share an exact name, which can have unintended side effects.
/talker
/talker

As you can see the warning clearly states that we are running two nodes with the same name because of which some unintended side effects might occur. Now run rqt_graph in the terminal and refresh it once. You will see the following graph:

As you can see in rqt_graph only one node is being displayed.

So we can conclude that when we run one node two or more times simultaneously then ros2 node list displays a warning while rqt_graph displays that one node is running but there are two nodes running that have the same name.

There can be some situations in which we need to run one node multiple times simultaneously. But if we do so then the name conflict will occur as two nodes running will have the exact same name. So to resolve this issue ROS 2 provides a feature using which we can change the name of our node at run time.

Experiment No.2: Changing Name of a Node at Runtime

Now run talker node in one terminal and type the following command in other terminal:

ros2 run demo_nodes_cpp talker --ros-args -r __node:=my_node

The first part of this command which is: “ros2 run demo_nodes_cpp talker” is used to run the talker node and the second part which is: “—ros-args -r __node:=my_node” is used to change the name of our node.

The name that you will write after equal to sign will become the name of your node. Here we have written “my_node” after the equal to sign so the name of our node will change from “talker” to “my_node”.

Now after executing this command run “ros2 node list” and you will see two different names as shown in the figure below:

The two names which are being displayed after running ros2 node list are:

talker
my_node

This means that currently there are two nodes running one of them is named talker while the second one of them is named my_node. Technically we are running the same node in two different terminals we have just changed the name of one node while running it second time.

As you can see no warning is being displayed now because now the nodes that are running do not have the same name. Now run the rqt_graph and refresh it once. You will see the following result:

Now you can see two names are being displayed because the two nodes that are running have different names. Earlier when two nodes were running simultaneously then only one name was being displayed in rqt_graph because they had the same name but now since the names are different so the graph will also change accordingly.

Section 4: Insights about Nodes

If you carefully observe our discussion that we did in the previous three sections then there are 8 major things that you learned about a node. These are:

Nodes can be broadly classified into two types. They are:
1. Built - In Nodes
2. Custom Nodes
Multiple nodes can run simultaneously.
If two nodes having the same name are running simultaneously and we used the command: “ros2 node list” then a warning message will be displayed.
Before running any node or ROS 2 command we have to run the following command:
```
source /opt/ros//setup.bash
```
Here should be replaced by your ROS 2 distribution name.
Syntax of the command to run a node is:
```
ros2 run  
```
Syntax of a command to change the name of a node during runtime is:
```
ros2 run   --ros-args -r __node:=
```
Remove the < and > signs while typing the command. They are just being used to write syntax.
There are two ways to check which nodes are currently active. They are:
1. By using command: ros2 node list
2. By using command: rqt_graph
Name of the executable and name of a node may or may not be same. These are two different things.

You might be confused about the difference between an executable name and a node name. This confusion will be cleared once you create your own node and then create an executable out of that node to run it.

In Part 2 of this tutorial series we exactly did this. We created a node and then created an executable out of it. So if you want to clear your confusion you can read the second part of this series by clicking the button given below.

ROS 2 Tutorial for Beginners (Part 2)

Section 5: Running Another Built - In Node

There is another Built - In Node which you can run to understand how nodes work. Open your terminator and split into 4 parts. Run the following command in one part:

ros2 run turtlesim turtlesim_node

Then you will see a turtle appearing on your screen like this:

Now click on another CLI window and run the following command:

ros2 run turtlesim turtle_teleop_key

Click on the terminal where you have executed this command to select it. Now press your arrow keys and you will notice that turtle starts moving. If you press forward key the turtle moves forward, if you press backward key it moves in backward direction, if you press the right key it turns right and if you press the left key it turns left.

Now you can use command like rqt_graph and ros2 command list to check which nodes are running.

When you use rqt_graph then you will see a complex graph as shown in the figure below:

Why such a complicated graph was displayed?

If you observe carefully then you can clearly see that you are running two different nodes and they are not working independently. They are communicating with each other.

When you are running the node “turtle_teleop_key” then you can control the turtle which appeared when you ran the node “turtlesim_node”. That means using the node “turtle_teleop_key” you are controlling the node “turtlesim_node”.

The communication between these two nodes is happening because of Topics. You might be thinking what are Topics? You will learn about them later in this tutorial series.

This communication between nodes that is happening via topics is the reason why the rqt_graph has became so complicated. Over time as you progress in your journey of learning ROS 2 you will be able to understand these graphs better.

Call To Action

Hundreds of tutorials will fail to teach you a concept if you yourself do not try to practice it. To really learn the concepts that we have discussed in this blog you must do the following tasks:

Run the talker node and introspect it using ros2 node list and rqt_graph
Run the turtlesim node and introspect it using ros2 node list and rqt_graph
Run these two nodes simultaneously and then again run rqt_graph
Kill one of these nodes and then again refresh and check rqt_graph
Experiment by running and then terminating these nodes to get a hang of it.

If you have any doubt then do let me know in the comments section. I will try to reply as soon as possible.

What’s Next

In next part which will be ROS 2 Tutorial for Beginners (Part 3): Understanding ROS 2 Nodes (Sub Part 2) we will be discussing how to run custom nodes. The next part will allow you to gain even more deep insights on how a node works. I will inform you once the next part is published.

Till the stay tuned and keep learning!

Edit:
Next part has been released!
Click on this link to read it: https://rossimplified.substack.com/p/ros-2-tutorial-for-beginners-part?r=61m4w1

About The Publication: ROS Simplified

- From Satyarth Shree, Founder and Editor-In-Chief of ROS Simplified

About The Author

Hi, I am Satyarth Shree a first semester BTech Robotics and Automation student at Lovely Professional University (LPU), India. I am an aspiring robotics engineer who is publicly documenting his learning journey using platforms like medium and wordpress. My areas of interests include ROS, python and mathematics. Currently I am focusing on ROS more. I have also started a publication named ROS Simplified to make ROS accessible to everyone by providing beginner friendly tutorials free of cost.