Category: General

Your Best Career Decision of the Next 50 Years

Why Investing in Robotics Skills Will Be Your Best Career Decision of the Next 50 Years

The Secret Sauce of Tech Billionaires

Ever wonder what makes tech companies like Uber, Google, and Airbnb so successful? Well, there’s a guy named Evan Williams who has a philosophy on what it takes. You might not know his name, but you’ve definitely used his creations. He’s the billionaire co-founder of Twitter and Medium, and he’s got a pretty simple recipe for success in the tech world.

Here’s Williams’ secret sauce: identify basic human desires that have existed for a long time, then use modern technology to fulfill those desires more conveniently than ever before. That’s it. 

At its core, his idea is simple yet profound. Williams argues that the Internet is “a giant machine designed to give people what they want.” The key to building successful tech companies, he suggests, is to remove steps from common activities, making them faster and cognitively easier for users.

Sounds simple, right? But this idea has made Williams and many others filthy rich. Making money in technology is all about providing speed and cognitive ease…don’t make me think, don’t make me wait.

Let’s break it down with some examples:

1. Google: Remember when finding information online meant clicking through a bunch of confusing directories? Google said, “Nah, just type what you want in this box.” Boom! Instant answers. Before Google, you’d spend ages navigating Yahoo! directories or trying to guess the right website URL. Now? You can find the capital of Uzbekistan in seconds.

2. Uber: Calling a cab used to be a pain. You’d stand on the street corner, arm raised, hoping to catch a driver’s attention. Or you’d call a dispatcher and pray they’d actually send someone. Uber made it as easy as tapping a button on your phone. No more waiting on hold or explaining where you are.

3. Airbnb: Booking a place to stay meant dealing with hotels and their prices. You’d have to call around, compare rates, and often settle for a cookie-cutter room. Airbnb lets you rent someone’s spare room or entire house with a few clicks. It opened up a whole new world of unique, often cheaper accommodations.

4. Amazon: Remember when shopping meant driving to the mall, fighting for parking, and hoping the store had what you wanted? Amazon brought the entire mall (and then some) to your fingertips. From books to electronics to groceries, it’s all just a click away.

5. Netflix: Back in the day, watching a movie meant driving to Blockbuster, hoping they had the film you wanted, and rushing to return it to avoid late fees. Netflix said, “How about we bring thousands of movies and shows right to your TV?” No more late fees, no more limited selection.

6. Spotify: Music lovers used to spend a fortune building CD collections or downloading individual songs. Spotify made virtually all the world’s music available for a small monthly fee. No more storage issues, no more buying albums for just one good song.

7. Instagram: Remember lugging around a camera, then waiting to develop film to share photos? Instagram made it possible to snap, edit, and share photos instantly. It turned everyone into a potential photographer and created a whole new way of visual communication.

8. LinkedIn: Networking used to mean attending stuffy events and exchanging business cards. LinkedIn brought professional networking online, making it easier to connect with colleagues, find jobs, and showcase your skills.

9. Zoom: Before Zoom, video conferencing was often a clunky, unreliable experience reserved for big corporations. Zoom made it so easy that grandparents could use it. It’s changed how we work, learn, and stay in touch with loved ones.

10. DoorDash: Remember when getting food delivered meant being limited to pizza or Chinese? DoorDash and similar apps brought virtually every restaurant to your doorstep. No more limited options or dealing with grumpy restaurant staff over the phone.

See the pattern? These companies all took something people were already doing and made it way faster and easier. Williams calls this “removing cognitive overhead.” In plain English, that means making things so simple that you don’t have to think about them.

I saw firsthand as the Chief Financial Officer of 21212 Digital Accelerator, the first tech startup accelerator in Brazil, how the most successful companies in our portfolio made a lot of money just by removing steps from what people were already doing.

Now, you might be wondering, “What does this have to do with robotics?” 

As we’ve seen, Evan Williams’ philosophy of simplifying existing processes has led to remarkable innovations in the digital realm, but this same principle could apply to robotics, potentially transforming our physical world in similar ways.

The Case for Robotics 

Applying Williams’ Principle to Robotics

The core idea of simplifying existing processes will be powerful in robotics:

1. Reducing Complexity: Just as Google simplified information retrieval, robots will simplify complex physical tasks.

2. Increasing Accessibility: Similar to how Uber made transportation more accessible, robots will make certain services or capabilities more widely available.

3. Enhancing Efficiency: In the same way that Amazon streamlined shopping, robots will streamline various industrial and domestic processes.

Fulfilling Age-Old Human Desires

Robots (humanoids in particular) will eventually satisfy numerous long-standing human desires:

  • Assistance: Humans have always sought help with tasks, from manual labor to cognitive work.
  • Safety: People have consistently sought ways to perform dangerous tasks without risking human lives.
  • Efficiency: Who doesn’t want to accomplish more in less time?

Roboticists will play an important role translating these desires into reality through advanced programming and AI integration.

Removing Steps and Cognitive Load

Just as Uber removed steps from the process of getting a ride, humanoid robots programmed by skilled software engineers will simplify countless aspects of daily life:

  • Home management: Robots will eventually handle cleaning, cooking, and organizing without the need for human intervention.
  • Eldercare: Humanoids will provide round-the-clock assistance to the elderly, reducing the cognitive and physical burden on human caregivers.
  • Industrial work: Complex manufacturing processes will be streamlined, with robots handling intricate tasks that currently require extensive human training and concentration.

Investment and Market Trends

The robotics industry is attracting significant investment:

  • Major tech companies like Tesla and Amazon are investing in robotics research and development.
  • Startups focused on specific robotics applications (e.g. humanoids) are securing substantial funding…sometimes in the hundreds of millions of dollars.
  • Government and academic institutions are also contributing to robotics research.

However, it’s important to approach market projections with caution, as the path from research to widespread commercial application can be long and uncertain.

Skills for the Future

Robotics will drive massive productivity gains across industries, from manufacturing to healthcare. Software engineers who can program these robots will be instrumental in unlocking trillions of dollars in economic value.

As robots become more sophisticated and ubiquitous, the need for skilled professionals who can design, program, and maintain these systems will skyrocket. While many jobs may be at risk of automation, robotics software engineers will be the architects of this automated future, making their skills not just valuable, but essential.

In essence, robotics engineering embodies Williams’ philosophy of tech success. It has the potential to remove steps from countless processes, increase speed, reduce cognitive load, and fulfill long-standing human desires. 

As we’ve seen with Google, Airbnb, and Uber, those who can harness these principles to create user-friendly, transformative technologies often end up leading billion-dollar companies.

So, if you’re considering your career options or looking to pivot into a field with immense potential, robotics should be at the top of your list. By investing in these skills now, you’re not just preparing for the job market of tomorrow – you’re positioning yourself to be at the forefront of a technological revolution that will shape the next 50 years and beyond.

For those passionate about technology and problem-solving, robotics offers an exciting career path with the potential to make significant impacts across various sectors over the next 50 years and beyond. As with any emerging technology, the key is to stay informed, continuously learn, and be prepared to adapt as the field evolves.

The robots are coming. The question is: will you be the one programming them?

That’s it. Keep building!

How to Upload a ROS 2 Project to GitHub

In this tutorial, I will show you how to store your ROS 2 project in a repository on GitHub.

In case you’re not familiar with GitHub, GitHub is an online platform specifically designed for software development. It offers several key functionalities:

  • Version control: This allows developers to track changes made to code over time. Imagine it like a time machine for your code, letting you revert to previous versions if necessary.
  • Code storage: GitHub acts as a secure and centralized location to store and manage code projects. Think of it like a cloud storage specifically for your code.
  • Collaboration: Teams can work together on projects by sharing code, discussing changes, and merging different contributions seamlessly.
  • Open-source contribution: GitHub is a hub for open-source projects, where developers can publicly share their code, contribute to existing projects, and learn from others.

Prerequisites

I have created a ROS 2 workspace that has a folder called mycobot_ros2 (i.e. /home/ubuntu/ros2_ws/src/mycobot_ros2).

Inside the mycobot_ros2 folder, I have two ROS 2 packages, mycobot_description and mycobot_ros2. You can see the complete repository here on GitHub.

Directions

Install Git

The first thing you need to do is install Git. Open a new terminal window, and type:

sudo apt-get update
sudo apt-get install git

Check the git version you have.

git --version

Configure Git

Configure your git username and email.

git config --global user.name "John Doe"
git config --global user.email "johndoe@example.com"
git config --global init.defaultBranch main

Initialize Git

Move to inside your project folder.

cd  ~/ros2_ws/src/mycobot_ros2/

Initialize the folder as a Git repository by running:

git init

Add and Commit the Files to Your Local Repository

Add the files in your folder to the repository with the following command:

git add .

Commit your staged files to your local repository with:

git commit -m "Initial commit"

Create the Remote Repository on GitHub

Go to GitHub and log in.

Click on the “+” icon in the upper right corner and select “New repository.”

Name your repository, add a description (optional), and choose whether the repository will be public or private.

Click “Create repository.”

Link the Local Repository to the Remote Repository

After creating your repository on GitHub, you’ll get a URL for that repository. Link your local repository to GitHub with:

git remote add origin <repository-URL>

Log in to your GitHub account.

Generate your personal access token. Read about how to do this here.

Finally, push your code from your local repository to GitHub with:

git branch --set-upstream-to=origin/main main

The command git branch –set-upstream-to=origin/main main links your local branch named “main” with its corresponding remote tracking branch “origin/main” on GitHub. This establishes a connection between the two branches, making it easier to keep them in sync in the future.

git push origin main --force

Type your GitHub username and personal access token.

Now if you go back to GitHub, you can see your repository.

Let’s add our LICENSE file again.

Go to your repository’s main page on GitHub.

Click on the “Add file” button on the top right corner.

Choose “Create new file”.

In the file name field, type LICENSE or LICENSE.md (all uppercase).

Click on “Choose a license template”.

Click OK when it asks about unsaved changes.

On the left side of the page, review the available licenses and select the one you want to use.

You can optionally add your name, year, and any additional comments in the file content below the chosen license text.

Click Review and Submit.

Click “Commit changes” (twice) to create the license file and add it to your repository.

Now make sure we get these changes locally.

Open a terminal window, and type:

git branch --set-upstream-to=origin/main main
git fetch
git status
git pull

I want GitHub to ignore the .vscode/ folder in the future.

touch .gitignore

Open the .gitignore file in a text editor.

gedit .gitignore

Add the following line to the file:

.vscode/

Save and close the file. This line tells Git to ignore the .vscode directory, meaning any files or subdirectories within .vscode/ will not be tracked or committed.

git add .gitignore
git commit -m "Add .gitignore to exclude .vscode directory"
git push 
git rm -r --cached .vscode
git commit -m "Stop tracking .vscode directory"

Remove the Need to Use a Username and Password

If you want to not have to use a username and password every time you run “git push”, you can use SSH keys. This page has the instructions on how to do that.

Here is the process…

Generate an SSH key pair (if you don’t already have one) by running:

ssh-keygen -t ed25519 -C "your_email@example.com"

When you get prompted for a password or saving location, just keep pressing Enter, which will accept the default.

Start the ssh-agent in the background.

eval "$(ssh-agent -s)"

Add your SSH private key to the ssh-agent:

ssh-add ~/.ssh/id_ed25519

Add the SSH public key to your Git server.

cat ~/.ssh/id_ed25519.pub

Copy the entire result to your clipboard by highlighting everything and copying it.

Go to your GitHub account “Settings” by clicking your profile icon in the upper right of the website.

Look for “SSH and GPG keys”.

Add a new SSH key, pasting the copied key there.

Go back to the main page of your repository on GitHub and find the SSH URL by clicking the green button labeled “Code”.

Copy the SSH URL that is in there.

Switch your repository’s remote URL to SSH by going to your Ubuntu Linux terminal window, and moving to the directory of your repository.

cd <path to your your local repository>
git remote set-url origin git@github.com:username/repository.git

That’s it!

Using SSH keys is a more secure and convenient method for machines where you regularly push changes, as it doesn’t require entering your credentials after the initial setup.

How to Create a ROS 2 C++ Subscriber – Iron

In this tutorial, we will go over how to create a C++ subscriber for ROS 2.

In ROS 2 (Robot Operating System 2), a C++ subscriber is a program (written in C++) that listens for messages being published on a specific topic.

Topics in ROS 2 are channels of communication named according to the type of information they carry, such as “/robot/speed” for speed information or “/camera/image” for vision information. Each subscriber in ROS 2 declares its interest in a particular topic and is programmed to react or process the messages received on that topic.

The official instructions for creating a subscriber are here, but I will walk you through the entire process, step by step.

We will be following the ROS 2 C++ Style Guide.

Let’s get started!

Prerequisites

Directions

Open a terminal, and type these commands to open VS Code.

cd ~/ros2_ws
code .

Write the Code

Go back to the Explorer (Ctrl + Shift + E).

Right-click on the src folder to create a new file called “minimal_cpp_subscriber.cpp”.

Type the following code inside minimal_cpp_subscriber.cpp:

/**
 * @file minimal_cpp_subscriber.cpp
 * @brief Demonstrates subscribing to string messages on a ROS 2 topic.
 *
 * Description: Demonstrates the basics of subscribing to messages within the ROS 2 framework. 
 * The core functionality of this subscriber is to display output to the terminal window
 * when a message is received over a topic.
 * 
 * -------
 * Subscription Topics:
 *   String message
 *   /topic_cpp - std_msgs/String
 * -------
 * Publishing Topics:
 *   None
 * -------
 * @author Addison Sears-Collins
 * @date 2024-02-15
 */

#include "rclcpp/rclcpp.hpp" // ROS 2 C++ client library for node creation and management
#include "std_msgs/msg/string.hpp" // Standard message type for string messages
using std::placeholders::_1; // Create a placeholder for the first argument of the function

/**
 * @class MinimalSubscriber
 * @brief Defines a minimal ROS 2 subscriber node.
 *
 * This class inherits from rclcpp::Node and demonstrates creating a subscriber and
 * subscribing to messages.
 */
class MinimalSubscriber : public rclcpp::Node
{
public:
    /**
     * @brief Constructs a MinimalSubscriber node.
     *
     * Sets up a subscriber for 'std_msgs::msg::String' messages on the "topic_cpp" topic.     * 
     */
    MinimalSubscriber() : Node("minimal_subscriber")
    {
        // Create a subscriber object for listening to string messages on 
        // the "topic_cpp" topic with a queue size of 10.
        subscriber_ = create_subscription<std_msgs::msg::String>
        (
            "/topic_cpp", 
            10, 
            std::bind(
                &MinimalSubscriber::topicCallback, 
                this, 
                _1
            )
        );	
    }

    /**
     * @brief This function runs every time a message is received on the topic.
     *
     * This is the callback function of the subscriber. It publishes a string message
     * every time a message is received on the topic.
     * 
     * @param msg The string message received on the topic
     * @return Void.
     */
    void topicCallback(const std_msgs::msg::String &msg) const
    {
        // Write a message every time a new message is received on the topic.
        RCLCPP_INFO_STREAM(get_logger(), "I heard: " << msg.data.c_str());

    }
	
private:
    // Member variables.
    rclcpp::Subscription<std_msgs::msg::String>::SharedPtr subscriber_; // The subscriber object.
};

/**
 * @brief Main function.
 *
 * Initializes the ROS 2 system and runs the minimal_subscriber node. It keeps the node
 * alive until it is manually terminated.
 */
int main(int argc, char * argv[])
{

  // Initialize ROS 2.
  rclcpp::init(argc, argv); 
  
  // Create an instance of the MinimalPublisher node and keep it running.
  auto minimal_subscriber_node = std::make_shared<MinimalSubscriber>();
  rclcpp::spin(minimal_subscriber_node);

  // Shutdown ROS 2 upon node termination.
  rclcpp::shutdown(); 

  // End of program.
  return 0; 
}

Configure CMakeLists.txt

Now we need to modify the CMakeLists.txt file inside the package so that the ROS 2 system will be able to find the cost we just wrote.

Open up the CMakeLists.txt file that is inside the package.

Make it look like this:

cmake_minimum_required(VERSION 3.8)
project(cobot_arm_examples)

# Check if the compiler being used is GNU's C++ compiler (g++) or Clang.
# Add compiler flags for all targets that will be defined later in the 
# CMakeLists file. These flags enable extra warnings to help catch
# potential issues in the code.
# Add options to the compilation process
if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

# Locate and configure packages required by the project.
find_package(ament_cmake REQUIRED)
find_package(ament_cmake_python REQUIRED)
find_package(rclcpp REQUIRED)
find_package(rclpy REQUIRED)
find_package(std_msgs REQUIRED)

# Define a CMake variable named dependencies that lists all
# ROS 2 packages and other dependencies the project requires.
set(dependencies
  rclcpp
  std_msgs
)

# Add the specified directories to the list of paths that the compiler
# uses to search for header files. This is important for C++
# projects where you have custom header files that are not located
# in the standard system include paths.
include_directories(
  include
)

# Tells CMake to create an executable target named minimal_cpp_publisher
# from the source file src/minimal_cpp_publisher.cpp. Also make sure CMake
# knows about the program's dependencies.
add_executable(minimal_cpp_publisher src/minimal_cpp_publisher.cpp)
ament_target_dependencies(minimal_cpp_publisher ${dependencies})

add_executable(minimal_cpp_subscriber src/minimal_cpp_subscriber.cpp)
ament_target_dependencies(minimal_cpp_subscriber ${dependencies})

# Copy necessary files to designated locations in the project
install (
  DIRECTORY cobot_arm_examples scripts
  DESTINATION share/${PROJECT_NAME}
)

install(
  DIRECTORY include/
  DESTINATION include
)

# Install cpp executables
install(
  TARGETS
  minimal_cpp_publisher
  minimal_cpp_subscriber
  DESTINATION lib/${PROJECT_NAME}
)

# Install Python modules for import
ament_python_install_package(${PROJECT_NAME})

# Install Python executables
install(
  PROGRAMS
  scripts/minimal_py_publisher.py
  scripts/minimal_py_subscriber.py
  #scripts/example3.py
  #scripts/example4.py
  #scripts/example5.py
  #scripts/example6.py
  #scripts/example7.py
  DESTINATION lib/${PROJECT_NAME}
)

# Automates the process of setting up linting for the package, which
# is the process of running tools that analyze the code for potential
# errors, style issues, and other discrepancies that do not adhere to
# specified coding standards or best practices.
if(BUILD_TESTING)
  find_package(ament_lint_auto REQUIRED)
  # the following line skips the linter which checks for copyrights
  # comment the line when a copyright and license is added to all source files
  set(ament_cmake_copyright_FOUND TRUE)
  # the following line skips cpplint (only works in a git repo)
  # comment the line when this package is in a git repo and when
  # a copyright and license is added to all source files
  set(ament_cmake_cpplint_FOUND TRUE)
  ament_lint_auto_find_test_dependencies()
endif()

# Used to export include directories of a package so that they can be easily
# included by other packages that depend on this package.
ament_export_include_directories(include)

# Generate and install all the necessary CMake and environment hooks that 
# allow other packages to find and use this package.
ament_package()

Configure package.xml

Now we need to configure the package.xml file.

Open the package.xml file, and make sure it looks like this:

<?xml version="1.0"?>
<?xml-model href="http://download.ros.org/schema/package_format3.xsd" schematypens="http://www.w3.org/2001/XMLSchema"?>
<package format="3">
  <name>cobot_arm_examples</name>
  <version>0.0.0</version>
  <description>Basic examples demonstrating ROS 2</description>
  <maintainer email="automaticaddison@example.com">Addison Sears-Collins</maintainer>
  <license>Apache-2.0</license>

  <!--Specify build tools that are needed to compile the package-->
  <buildtool_depend>ament_cmake</buildtool_depend>
  <buildtool_depend>ament_cmake_python</buildtool_depend>

  <!--Declares package dependencies that are required for building the package-->
  <depend>rclcpp</depend>
  <depend>rclpy</depend>
  <depend>std_msgs</depend>

  <!--Specifies dependencies that are only needed for testing the package-->
  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>

  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>

Build the Workspace

cd ~/ros2_ws
colcon build
source ~/.bashrc

Run the Nodes

First run your publisher node.

ros2 run cobot_arm_examples minimal_cpp_publisher 
23-run-cpp-publisher-1
24-topic-echo-cpp-publisher-1

Now run your subscriber node.

ros2 run cobot_arm_examples minimal_cpp_subscriber
27_minimal_cpp_subscriber

An Important Notes on Subscribers and Publishers

In the example above, we published a string message to a topic named /topic_cpp using a C++ node, and we subscribed to that topic using a C++node. 

ROS 2 is language agnostic, so we could have also used a Python node to the publishing and a C++ node to do the subscribing, and vice versa.

That’s it for now. Keep building!