Computer Science & Robotics - Learn by Doing! Linux to ROS 2

Explore Linux as the open source foundation for robotics software, tracing its Unix roots, the Linux kernel and GNU tools, and how Debian, Red Hat, and Ubuntu shaped its distributions.

Ubuntu, a popular beginner-friendly Linux distribution based on Debian with desktop and server editions, offers long-term support and regular security updates, and powers ROS in robotics.

learn how to install Ubuntu using three options: virtual machine, dual boot, and Windows Subsystem for Linux, highlighting performance trade-offs for robotics and the course's virtual setup.

Download and install Oracle VirtualBox on Windows, create an ubuntu 24.04 virtual machine, allocate memory (e.g., 8 gb) and 25 gb disk space, boot, install ubuntu, and log in.

Install Ubuntu on Windows via Windows Subsystem for Linux (WSL), enable it, restart the PC, and install Ubuntu 22 or 24 through PowerShell, using a terminal-only session with no GUI.

Explore the Ubuntu desktop interface—dock, top bar, workspaces, and system menu—then master the Linux terminal for fast, powerful robotics tasks.

Navigate the Linux file system from the command line and understand the root directory and key folders like /bin, /dev, /etc, /home, /opt, /var, /lib, and /tmp for robotics.

Open a terminal from the menu or Ctrl+Alt+T, and learn pwd, cd, ls (with -l and -a for details and hidden files), mkdir, touch, rm, and cp.

Explore how Linux package management works, using dpkg and apt to install, remove, and query deb packages, handle dependencies, and ensure secure, atomic updates with sudo.

Learn to install software on Ubuntu with dpkg and apt, manage dependencies, and use repositories and PPAs to source packages for robotics projects with ROS.

Learn how Linux treats everything as a text file, and master standard streams, redirection, and common editors like Vim, Nano, and gedit to manipulate text for robotics workflows.

Learn to edit text files using Vim, nano, and gedit, and master quick commands like echo, cat, and head for creating, saving, and inspecting files in the terminal.

Explore how Linux defines files as byte sequences, and master the users, groups, and file permissions that control access with read, write, and execute.

Learn linux networking basics: inspect interfaces, manage connections from the command line, and remotely access robots; understand IPv4 addresses, subnet masks, and when to use static versus dynamic IP.

Learn how to find and configure IP addresses on Linux, distinguish IPv4 and IPv6, set static or dynamic addresses with Netplan, and test connectivity with ping and Nmap.

Establish secure remote connections to robots and computers with SSH and OpenSSH, transfer files using SCP and SFTP, and browse remote file systems with FileZilla over encrypted channels.

Access linux devices remotely with OpenSSH, configure client and server, use ssh keys for passwordless login, and transfer files with scp or ftp via FileZilla.

Explore environmental variables in Linux, key-value pairs that configure the system and applications, including path and home directory variables, and how to view and create them.

Learn how to view, set, persist, and manage environment variables in Linux using echo, printf, export, and bashrc, including loading changes with source.

Learn bash scripting to automate linux tasks and schedule them with cron, then manage services with systemd and systemctl for reliable startup, running, and logging.

Develop automation skills in Linux by scripting with bash, creating cron jobs and aliases, and managing services with systemd and systemctl to enable backups and monitoring.

Explore advanced Linux shell concepts, compare Bash, Dish, Zsh, and Fish, and learn to switch your default shell, configure features, and leverage grep, awk, sed, and piping for efficient workflow.

Learn to install terminator or tmux and manage multiple Linux terminal windows to streamline robotic software development, boost efficiency, and reduce errors.

Install terminator and tmux to create persistent, multi-panel sessions on remote robots, save layouts, and detach and reattach without stopping running scripts.

Learn how Docker containers package applications and dependencies into portable units that run the same across environments, enabling faster robotics development and easy collaboration.

Explore docker images as immutable blueprints with all dependencies, then run containers to create isolated, ephemeral environments and understand how docker differs from virtual machines.

Install and verify Docker on Ubuntu via the apt package manager, including configuring gpg keys, certificates and curl prerequisites, adding the Docker repository, and running a hello world container.

Learn to pull and run Docker images from Docker Hub and Docker App, use tags for reproducible environments, and link to GitHub or GitLab for automatic image updates.

Search Docker Hub for Python images and select official images with version tags, then pull. Docker lets you run ROS 2 versions regardless of your host Ubuntu version using humble.

Discover how docker images are built in immutable layers with unique IDs, enabling layer sharing to save space, and how containers transition from create to start, stop, and delete.

Understand how Docker containers run in isolation, use volumes for persistent data shared with the host, and navigate bridge and host networking to expose services.

Learn three methods to create docker images, from committing container changes to building with dockerfiles. Dockerfiles document steps, track environment changes, and enable sharing of exact, maintainable images.

Learn to share a persistent host directory with docker using docker run -v, compare bridge and host networking, and distinguish docker run versus docker start for container management.

Create and customize docker images in an immutable container, then save and share them. Tag and push to Docker Hub; consider private options or a local registry.

Learn to create a Dockerfile that runs a Python hello script, build with docker build, tag images, and compare base versus slim images for lightweight deployment.

Learn to build advanced docker images from an ubuntu base image, install dev tools and python, and use a dockerfile and entrypoint to clone a repo, compile, and run.

Learn to simplify multi-container robotics projects with Docker Compose, configure services in a docker-compose.yaml, and launch all containers with a single command.

Define and run docker compose services with a YAML file to manage development containers. Override startup commands, configure volumes and environment variables, and explore scaling options using docker compose.

Master advanced docker compose features, including building images from the compose file and caching, to streamline development and support multi-container robotics simulations and applications.

Explore how to display graphical user interfaces from Docker containers using X11 and Wayland, understand the display server, environment variables, and X server access control.

Configure and test graphical apps in docker by verifying display protocols, sharing the X11 socket, and adjusting docker compose and user permissions to render windows.

Enable Nvidia GPU access inside Docker containers for robotics development, using the Nvidia Container Toolkit to inject GPU drivers and accelerate simulation, deep learning, and computer vision.

Set up a local Docker registry to keep images private, secure access, and enable offline, faster deployments from a local network, protecting intellectual property.

Install and run a local Docker registry, push and pull images over port 5000, and persist data with a host volume to share images across networked robots.

Master git as a distributed version control tool to track code, view changes, and revert safely across teams. Compare GitHub with git and other hosting services for online repositories.

Explore GitHub as the leading platform for hosting git repositories and collaboration. Inspect repositories, use issues and pull requests, and create an account to start with public projects.

Explore git terminology by treating commits as snapshots that save your project's state and enable reverting changes. Use branches for isolated, parallel development and merging back to main.

Explore the git workflow and lifecycle management from initializing a local repository and staging changes to committing with messages, then pushing to GitHub or GitLab to enable collaboration.

Learn to create your first git repository on GitHub, configure your identity, add, commit, and push code to a remote origin, and clone or pull updates.

Learn to manage Git repositories on GitHub with SSH authentication, configure remotes (origin, backup), push with upstream tracking, and ignore the build directory with a .gitignore file.

Master branching workflows in git to collaborate on large projects, switch between feature and bug-fix branches with checkout, and merge changes into main while resolving conflicts.

Explore git branching and workflow practices: switching between main and feature branches, committing, merging, resolving conflicts, and using stash and log to manage development history.

Learn how to use git fetch and git rebase to incorporate updates from the upstream main branch into a feature branch, rewriting history for a clean, up-to-date feature.

Explore how git fetch, diff, and rebase rewrite history to create a clean linear commit history, compare rebase with merge, and practice resolving conflicts on private branches.

Create a readme.md to document your repository with markdown, outlining dependencies, setup, and how to clone, build, run, and format code blocks.

Explore how DevOps links software development and IT operations using GitHub Actions to automate testing, building, and deploying code through a CI/CD pipeline.

learn how to create and manage GitHub actions workflows for building, testing, and deploying code; handle public and private dependencies, checkout steps, secrets, and artifact uploads in a ci/cd pipeline.

Collaborate effectively by forking repositories and making changes in your fork. Create pull requests to merge those improvements into the main development branch after review.

Fork a repository, clone it, and sync with upstream while inviting collaborators, creating branches, submitting pull requests, and merging changes for collaborative development.

Compare editors and IDEs for robotics, from Vim and nano to Visual Studio Code, noting Docker, ROS 2, Copilot, LLMS, and rich extensions.

Explore Visual Studio Code, a lightweight free editor serving as a digital workspace for coding, testing, and debugging. Install the deb package on Linux, then explore explorer, terminal, and extensions.

Install and explore the Microsoft C/C++ extension in VSCode to enable syntax highlighting, IntelliSense, and debugging for C++ projects; learn to enable, use autocompletion, and manage extensions.

Connect to remote hosts using the remote SSH extension in Visual Studio Code to edit, run, and debug code directly on robots or servers via SSH.

Learn to streamline robotics development with docker in VS Code by managing containers and images via remote explorer or docker extension, and create dev containers using docker and compose configurations.

Clone a GitHub repository in Visual Studio Code, create and switch branches, modify and commit changes, resolve conflicts, and push updates using the integrated source control panel.

Discover how ROS standardizes disparate robot modules into a flexible middleware, enabling seamless interoperability and access to navigation, localization, perception, and manipulation tools.

See how ros 2 manages drivers and interfaces, enabling you to reuse a module across robots with different cameras and motors and simplify integration as a robot operating system.

Install ros 2 on ubuntu, set locales to utf-8, add the ros2 repository and gpg key, install the desktop and development tools, and verify with ros2 --help.

Understand the ROS 2 architecture built around the DDS middleware, enabling robust node communication; explore the RMW and RCL layers and language bindings in C++, Python, and Java.

Explore how ROS 2 provides a hardware abstraction layer that unifies sensors and actuators behind standard interfaces, enabling developers to focus on higher-level autonomous navigation, perception, and planning.

Explore how ROS 2 uses device drivers to control hardware via a standardized interface, enabling camera applications to send commands and retrieve data without low-level protocol concerns.

Explore ROS 2 package management to organize robot source code into modular packages that share a common goal, enabling reuse across robots, maintainability, and easy deployment on robots or simulations.

Explore the ros2 command line interface to install and manage packages, list and run nodes, and inspect their execution using apt updates, ros2 pkg, and ros2 node info.

Explore how ROS 2 topics enable publisher and subscriber communication across unique channels, with varying message types, including int32, strings, and complex or custom messages.

Learn how ros2 topics enable inter-node communication via the cli. Watch the talker publish on chatter, inspect topic info, and publish new messages to observe frequency.

Expose a single face recognition function through ROS 2 services, enabling a service server and client to exchange a request and a response, avoiding code duplication across nodes.

Explore ros2 services, run a service server that sums two integers, inspect service interfaces, and call the service from a client to observe requests and responses.

Learn how ros2 actions connect an action server and client via goal, feedback, and result messages to manage long-running tasks like autonomous navigation and cancel when needed.

Explore ROS 2 actions with the action CLI by running a Fibonacci action server and client. Use goals, feedback, and results to compute the Fibonacci sequence up to order.

Explore how to create your first ROS 2 package from scratch, and understand underlay and overlay workspace layers for source code, configuration, parameters, and launch files.

Build an autonomous mobile robot with ROS 2 and Bumper Bot, learning to download open-source code, install dependencies, run examples, and explore packages for description, control, mapping, and navigation.

Learn to manage ROS 2 package dependencies with rosdep in a bumper boat workspace, install required packages, and run the robot navigation simulation in a Docker container.

Learn how ros2 launch files group nodes, manage dependencies, and configure parameters with a single command. They can be written in python, xml, or yaml to describe operations.

Launch files start the robot from a docker container, initiating the simulation in a small house world, the control system, and autonomous navigation with ROS 2 launch and node logs.

Explore Gazebo as a ROS 2 physics engine that simulates robot motion and sensors, enabling virtual environments and seamless transition of the same interface from simulation to real hardware.

launch the bumper bot in gazebo via docker and ros2, visualize the 2d lidar scans, and tune the real time factor by adjusting the step size for smoother simulation.

Visualize ros2 messages with Arviz to interpret maps and sensor data, including occupancy grids, laser scans, and camera images, and publish goals to see the robot autonomously navigate in simulation.

Visualize ROS 2 messages with rviz to read maps, laser scans, and camera images through topics. See a robot navigate autonomously to a goal, planning paths and avoiding obstacles in Gazebo.

Use Raspberry Pi Imager to flash the Raspberry Pi microSD with Ubuntu Server 24.04 or 22, enable SSH, configure Wi‑Fi and locale, and create a login for ROS 2 deployment.

Install ROS 2 jazzy on Ubuntu 24 for the Raspberry Pi, or humble on Ubuntu 22, configure the ROS environment, install dependencies with rosdep, and build the bumper bot workspace.

Learn to remotely connect to a wifi-connected Raspberry Pi robot via SSH, configure Netplan for a static IP, and enable passwordless login by generating and copying an SSH key.

Engage in hands-on robot assembly as part 1 of a practical Linux to ROS 2 learning path in a learn-by-doing robotics course.

Assemble the robot in part 4 guides hands-on hardware assembly and setup within Linux to ROS 2 workflows.

Log into a raspberry pi and run ros2 launch in a tmux session to operate a real robot with joystick teleoperation. Automate startup with a bash script and systemd service.

Revisit Linux fundamentals, Docker, Git, and ROS 2, and learn to install a Linux distribution, navigate the file system, manage permissions, and build reproducible development environments for robotics.

Explore fundamentals of autonomous mobility, including control, localization, mapping, navigation, and obstacle avoidance. Learn by doing with real or simulated robots, testing control algorithms, kinematics, and trajectory planning.