Skip to content

Glossary

A comprehensive reference for key terms and concepts used throughout the Robotics Programming Course.

A

Abstract Base Class (ABC)
A class that cannot be instantiated directly and is designed to be inherited by other classes. Contains one or more abstract methods that must be implemented by concrete subclasses.
Algorithm
A step-by-step procedure for solving a problem or completing a task, often implemented as a function or method in programming.
API (Application Programming Interface)
A set of protocols, routines, and tools for building software applications. Defines how software components should interact.
Argument
A value passed to a function or method when it is called. Arguments provide input data for the function to process.

B

Binary Search
An efficient algorithm for finding an item in a sorted list by repeatedly dividing the search interval in half.
Bug
An error or flaw in a computer program that causes it to produce incorrect or unexpected results.

C

Class
A blueprint or template for creating objects in object-oriented programming. Defines attributes and methods that the objects will have.
Class Method
A method that belongs to the class rather than any particular instance. Defined using the @classmethod decorator in Python.
Component
A modular, reusable piece of software that encapsulates functionality and can be integrated into larger systems.
Constructor
A special method called when an object is instantiated. In Python, this is the __init__() method that initializes the object's state.
Control System
A system that manages and regulates the behavior of other systems using control loops and feedback mechanisms.

D

Debugging
The process of finding and fixing bugs or errors in computer programs.
Dependency
A relationship where one piece of software relies on another to function properly.
Docstring
A string literal that appears as the first statement in a Python module, function, class, or method definition, used for documentation.
Duck Typing
A programming concept where the type or class of an object is less important than the methods it implements.

E

Encapsulation
An OOP principle that bundles data and methods that operate on that data within a single unit (class), hiding internal implementation details.
E-puck Robot
A small differential wheeled mobile robot developed for education and research, commonly used in robotics courses. Known for its small size (~70mm diameter), circular shape, and comprehensive suite of sensors including proximity sensors, distance sensors, and line sensors.

Course Context (2026): The course has migrated from e-puck (Weeks 1-12, OOP fundamentals) to Unitree GO2 quadruped robots (Weeks 13-18, advanced integration). Archived Sessions 13-15 contain e-puck + Webots materials; current course uses GO2 + Gazebo. OOP design patterns and ROS2 concepts learned with e-puck remain directly applicable to GO2.

Exception
An error that occurs during program execution, which can be handled using try-catch blocks to prevent program crashes.
Exercism
An online platform providing coding practice exercises with mentorship, used for skill development in various programming languages.

F

Felipe Martins Labs
A series of progressive robotics exercises focusing on robot navigation, sensor processing, and autonomous behavior implementation.
Function
A reusable block of code that performs a specific task, takes inputs (parameters), and may return a value.

G

Git
A distributed version control system used for tracking changes in source code during software development.
GUI (Graphical User Interface)
A visual interface that allows users to interact with software through graphical elements like buttons, menus, and windows.

I

IDE (Integrated Development Environment)
A software application providing comprehensive facilities for software development, typically including a code editor, debugger, and build automation tools.
Inheritance
An OOP principle allowing a class to inherit attributes and methods from another class, promoting code reuse and establishing hierarchical relationships.
Instance
A concrete occurrence of a class; an object created from a class blueprint with its own unique state.
Instance Method
A method that operates on an instance of a class and has access to the instance's attributes through the self parameter.
Instance Variable
A variable that belongs to a specific instance of a class, holding data unique to that object.
Integration Testing
Testing performed to verify that different modules or components work correctly when combined.

L

Library
A collection of pre-written code and functions that can be imported and used in programs to provide specific functionality.
Line Following
A robotic behavior where a robot follows a predetermined path marked by a line on the ground using sensors.

M

Magic Method (Dunder Method)
Special methods in Python that start and end with double underscores (e.g., __init__, __str__), providing customizable behavior for built-in operations.
Method
A function defined within a class that can access and manipulate the object's attributes.
Method Resolution Order (MRO)
The order in which Python searches for methods in a class hierarchy, important for inheritance and method overriding.
MkDocs
A static site generator designed for creating project documentation from Markdown files.
Modularity
The design principle of breaking down complex systems into smaller, independent, and interchangeable components.

O

Object
An instance of a class that contains data (attributes) and code (methods) that operate on that data.
Object-Oriented Programming (OOP)
A programming paradigm based on the concept of objects, emphasizing encapsulation, inheritance, and polymorphism.
Odometry
A method of estimating position and orientation of a robot based on data from motion sensors.
Operator Overloading
The ability to define custom behavior for built-in operators (like +, -, ==) when used with user-defined classes.

P

Package
A collection of related modules organized in a directory structure, providing a way to organize and distribute code.
Parameter
A variable listed in a function definition that accepts values passed as arguments when the function is called.
PID Controller
A control loop mechanism that uses Proportional, Integral, and Derivative terms to minimize error in system control.
Polymorphism
An OOP principle allowing objects of different classes to be treated as instances of the same type through a common interface.
Portfolio Assessment
An evaluation method where students compile a collection of work demonstrating their learning and competency development.
Property
A Python feature that allows methods to be accessed like attributes, often used with getter and setter methods.
pytest
A testing framework for Python that makes it easy to write simple and scalable test cases.
Python
A high-level, interpreted programming language known for its simplicity and readability, widely used in robotics and education.

R

Refactoring
The process of restructuring existing code without changing its external behavior to improve readability, maintainability, or performance.
Repository
A storage location for software packages or source code, often managed by version control systems like Git.
Robotics
The interdisciplinary field combining mechanical engineering, electrical engineering, and computer science to design and operate robots.
ROS (Robot Operating System)
An open-source framework providing tools, libraries, and conventions for developing robot software.

S

Sensor
A device that detects and measures physical properties from the environment and converts them into signals for processing.
Simulation
The use of computer models to replicate real-world processes or systems for testing, training, or analysis purposes.
Static Method
A method that belongs to a class but doesn't access instance or class-specific data. Defined using the @staticmethod decorator in Python.
Subclass
A class that inherits from another class (superclass), extending or modifying its functionality.
Superclass (Parent Class)
A class from which other classes inherit attributes and methods.

T

Test-Driven Development (TDD)
A software development approach where tests are written before the actual code implementation.
Test Suite
A collection of test cases designed to verify that a software application behaves as expected.
Type Hint
Python syntax that allows developers to indicate the expected data types of function parameters and return values.

U

Unit Testing
Testing individual components or modules of software in isolation to ensure they work correctly.
UML (Unified Modeling Language)
A standardized modeling language used to visualize system design and architecture.

V

Variable
A named storage location in computer memory that holds data that can be modified during program execution.
Version Control
A system that records changes to files over time, allowing you to recall specific versions and collaborate with others.
Virtual Environment
An isolated Python environment that allows you to install packages without affecting the global Python installation.

W

Webots
A professional mobile robot simulation software package that provides a complete development environment for modeling, programming, and simulating mobile robots.

Course Context (2026): Webots was used in earlier course iterations with e-puck robots. The current course (Weeks 13-18) has migrated to Gazebo (Simulate) with Unitree GO2 quadruped robots for more advanced robotics concepts and real-world hardware compatibility. See archived sessions 13-15 for historical Webots integration patterns that remain architecturally relevant to any robot simulation.

Wheel Encoder
A sensor that measures the rotation of robot wheels, used for odometry and motion control.

Additional Resources

Expanding Your Knowledge

For more detailed explanations of programming concepts, consider these resources:

  • Python Official Documentation: python.org
  • Real Python Tutorials: In-depth Python programming guides
  • ROS Documentation: ros.org
  • Webots User Guide: Comprehensive simulation environment documentation

Course-Specific Terms

This glossary focuses on terms relevant to ICTPRG430 and ICTPRG439. Additional robotics and programming terminology may be encountered in advanced coursework.

Last updated: August 2025 | Suggestions for additional terms? Contact your instructor.