
Robotics Development Environment with ROS in C++ and Python - protontypes
https://github.com/Ly0n/awesome-robotic-tooling
======
a_t48
ROS is really great for getting started with robotics, but from my experience
(and from others who I've talked to) tends to buckle under its own weight in
larger projects. This isn't to say you shouldn't use it, just be careful with
it. It has some really questionable design decisions and implementation
details that can bite you later.

~~~
Abishek_Muthian
Isn't this the case with any Python development in general? Once you start
building at scale you'll be forced to use Cython extensions and other non-
native python code.

~~~
stinos
_Isn 't this the case with any Python development in general?_

No this isn't generally true for Python, and I'm not sure why you'd be forced
to use Cython for things at scale. Unless you have some particular type of
software in mind perhaps?

~~~
Abishek_Muthian
>Unless you have some particular type of software in mind perhaps?

Webservices. May be its fine for couple of hundred users, but when there are
thousands of concurrent users with heavy I/O I've been forced to replace
asyncio with uvloop, replacing coroutine with gevent, implementing pre-fork
worker models etc. to get decent performance.

I've since then moved any webservices development to Golang and has been
perfect.

I understand there are large scale companies like Instagram which supposedly
use Python and I don't detest it. It's just there are better tools for job
now, especially for a lean startup and of-course Python has it's advantages
like being a good first programming language and large library ecosystem.

------
heyflyguy
If you want to really enjoy the ingenuity of people that otherwise might be
considered "simple", check out the ROS for Agriculture group and slack
channels. People converting 70s and 80s era farm equipment to be automated,
and it's pure gold.

~~~
BayezLyfe
any specific links to these groups??

~~~
heyflyguy
Website: [http://rosagriculture.org/](http://rosagriculture.org/) Slack:
[http://rosagriculture.slack.com/](http://rosagriculture.slack.com/) GitHub:
[https://github.com/ros-agriculture](https://github.com/ros-agriculture)
Twitter: @ROSAgriculture YouTube:
[https://www.youtube.com/channel/UCnr6AObsHnHSGPge0HVlBpA](https://www.youtube.com/channel/UCnr6AObsHnHSGPge0HVlBpA)

------
carapace
I was reading up on ROS the other day when the thought occurred that Erlang
is, in many ways, similar to some of the core functionality of ROS, and might
be a good substitute for [parts of] it.

~~~
jefft255
It’s true, the reason for choosing C++ and Python as first class languages is
because of their strength in numerical computing and AI capabilities (for
python anyway), which erlang mostly lacks. It would definitely be cool to be
able to use erlang though.

~~~
ssivark
No offense (I use Python all the time), but Python seems almost like the worst
of all worlds, except for ease of use in the first month of using it -- with
its only advantage being library inertia (which is a massive advantage in
practice though).

As eg: here's an excellent talk on the cruft in Python internals by Armin
Ronacher:
[https://www.youtube.com/watch?v=qCGofLIzX6g](https://www.youtube.com/watch?v=qCGofLIzX6g)

For more discussion on why Python is slow:
[https://news.ycombinator.com/item?id=12025309](https://news.ycombinator.com/item?id=12025309)

There is, after all, a graveyard littered with big-money attempts to speed up
(mutually incompatible) subsets of Python.

But lack of inertia not something that should deter someone seriously invested
(after all, Google/FB created Tensorflow/Pytorch respectively, and now Google
might be getting behind Swift). It's a judgement call on whether one feels
that most of the work/innovation still needs to be done, or is already done.
If it is yet to be done, building on top of a better platform is almost a no-
brainer.

~~~
isatty
I disagree. I think that the use of Python in ROS is the best of both worlds.
ROS makes it easy to do sane-ish IPC even for folks new to programming and
enables them to offload heavy numerical processing or real time tasks out to
C++ or even other boards on your robot.

Python sits by handling state machines (decision making) and similar logic.
It’s also great in experimental code that folks want to change often (opencv
prototyping).

I don’t like the lack of a type system and have run into easily preventable
bugs with python but in my case the trade off with developer productivity was
worth it.

------
abalaji
I brought ROS to FIRST robotics back when I was in high school and I still
think it continues to change the game for how people work with robots [1, 2]
The modularity / plug-n-play nature of the system makes swapping sensors
(which often have ROS driver) or algorithms that much easier.

[1]
[https://www.firstinspires.org/robotics/frc](https://www.firstinspires.org/robotics/frc)
[2] [https://www.chiefdelphi.com/t/paper-team-900-presents-
zebrav...](https://www.chiefdelphi.com/t/paper-team-900-presents-
zebravision-5-0-ros-for-frc/160468)

------
tlarkworthy
I kind of feel ROS rebuilt a ton of Google tech before it was open sourced.
rosbuild is bazel, Ros messages are protobuffers/flatbuffers, orchistration is
k8s. I feel we could do a better job these days with the newer tools rather
than ROS's less maintained, less interesting to researchers, reimplementation
of infra tech.

~~~
ragebol
I've seen IPC tools be built from scratch or on top of more popular stuff in
several companies I worked in, unfortunately.

ROS2 is building on DDS, which is a standardized protocol and has
implementations from multiple vendors as well as open source implementations,
with QoS built in etc.

~~~
tlarkworthy
yeah that looks cool but DDS is a technology designed for air gapped
factories. AFAIK most ROS teams are still using ROS1 due to the lack of cross
language tooling in ROS2. Again, bazel + gRPC* could solve this.

* or perhaps better is flatbuffers see tensorflow-lite

~~~
ragebol
gRPC, ZeroMQ, RabbitMQ, ActiveMQ, there's a whole bunch of them. The decision
to use DDS is explained here in
[https://design.ros2.org/articles/ros_on_dds.html](https://design.ros2.org/articles/ros_on_dds.html)

~~~
tlarkworthy
yes I read it at the time. However, HTTP3 + QUIC config [1] of gRPC _also_
runs over UDP with more fallbacks to make it work over commodity hardware. DDR
is a pain for random labs to work with as you have to have admin control over
the network and bridges to make it work. This basically means it can't be used
in the cloud or most corporate environments. It has huge deployment friction.
Given the bad uptake of ROS2, I think the market agrees with me.

Note QUIC and HTTP3 were not really a thing when ROS2 was conceived, but the
problem of head of line blocking was known and ROS2 was just a bit too ahead
of the curve.

[1] [https://www.fastly.com/blog/why-fastly-loves-quic-
http3](https://www.fastly.com/blog/why-fastly-loves-quic-http3)

~~~
ragebol
I think the market is pretty into ROS2 actually, its just the PhDs and grad
students that will be on ROS1 for a longer time because they don't have the
resources to make any switch. Amazon and a lot of other companies are big on
ROS2.

------
ragebol
I've been using ROS for some 8+ years now, for university projects,
competitions like RoboCup@Home and for work on robots operating in the wild,
on water, land and among people in malls etc.

I've seen many RoboCup teams convert from their custom stuff to ROS because it
allows to profit for so much other great work. In my own team, we replaced
most custom stuff implemented in the early days of ROS and with ROS with the
now de-facto standard ROS stuff for the same task so we can focus more on the
stuff that made us win the competition this year :-)

------
Animats
Well, yes, that's what ROS does. This "Awesome robotic tooling" GitHub
repository adds what? A package index?

~~~
protontypes
ROS has already a package index:
[https://index.ros.org/packages/](https://index.ros.org/packages/)

The list is more intendet to find the gems of modules, resources and tools for
an professional robotic development.

------
WhatNewSoftware
Can this be easily setup on Windows?

Was my biggest obstacle to using ROS in the past.

~~~
rmattes
I've never tried it, so I don't know how easy it is, but there has been a lot
of work recently to improve ROS on Windows: [https://microsoft.github.io/Win-
RoS-Landing-Page/](https://microsoft.github.io/Win-RoS-Landing-Page/)

~~~
danbmil99
Why?

~~~
rmattes
Why haven't I tried ROS on Windows? I never really had the need to, I
primarily use Linux at home and work.

I did briefly evaluate ROS 2 (ardent) on Windows at my previous job. It seemed
to work fairly well, I built it natively, ran the demos and did some
latency/throughput comparisons between DDS implementations.

