Difference between installing ROS from source and already-built one

edit

Source code is the human-readable and editable representation of a ROS package (or any other computer program). You need that for making changes to the program.

In most cases, some form of translation is required before a source program can be run on a computer. That is often called building the program. In ROS, rosmake will build any source package.

For relatively recent versions of Ubuntu Linux, the ROS community provides pre-built packages in native Ubuntu format. Those packages are usually easier and less error-prone to install.

Most ROS packages depend on other ROS packages for needed interfaces. For them, installing pre-built binary packages makes sense.

You'll save yourself a great deal of time (and a fair amont of pain) if you use pre-built binary packages wherever you can. As has been pointed out above, this won't work for packages you're currently coding on; those need to be recompiled every time you change something.

For things you aren't actively changing, having the pre-built binaries can save you a lot of time (building some of them takes hours) and guarantees that you're coding against the very same version of ROS that the rest of us are using, thereby making sure your code is portable.

I think the others missed pointing out why you might want to compile from source. Pre built binaries are useful if default vanilla build options will suit you. There are various use cases where this is not desirable though and rosinstall'ing ( http://www.ros.org/wiki/electric/Installation/Ubuntu/Source) becomes easier.

• setting custom cflags (eg optimisation for an intel atom cpu, or for size or globally setting a macro)
• changing the build mode (debug, ...)
• cross compiling

Note that you probably want to avoid recompiling pre built debs as you will have to muck around with permissions and you will have to watch for whenever the debs install an updated version.

I've used Gentoo for a long time, chasing the idea that compiling the source code enables you to optimize the binaries for you specific machine. I think this hold only when you have some fancy hardware or when gcc supports the specific architecture you're working with. For example, a compiler might align your data so that they will create less cache miss given your processor's cache size.

In practice, the speed-up is often barely noticeable, so using binaries is most of the time no different from compiling the source code.

Unless one wants to do things the real geeky way :)