Skills Programming & Software

Programming & Software

Write code.
Run the robot.

Students learn Java from scratch and progress to full autonomous routines with sensor fusion and computer vision, using the same tools as professional software engineers. No prior experience required.

Apply Now Explore Mechanical
Aimer.java — Team 23638 Firestorm 
/**
 * Computes a velocity-compensated aim point.
 * Iteratively adjusts for robot motion during
 * the ball's time of flight.
 */
private Vect2 computeVelocityCompensatedPosition(Vect2 targetPos) {
    Vect2 shooterPos = computeShooterPosition();
    Position robotVel = drivetrain.getVelocity();

    double distance = Vect2.getDistance(shooterPos, targetPos);
    double timeOfFlight = shooterConfig.getTimeOfFlight(distance);
    Vect2 correctedPosition = targetPos;

    for (int i = 0; i < 20; i++) {
        correctedPosition = new Vect2(
            targetPos.getX() - robotVel.getX() * timeOfFlight,
            targetPos.getY() - robotVel.getY() * timeOfFlight
        );
        distance = Vect2.getDistance(shooterPos, correctedPosition);
        timeOfFlight = shooterConfig.getTimeOfFlight(distance);
    }

    return correctedPosition;
}

01 / Hello, Robot

Java fundamentals. First deployment. First motor spin.

The first time a student deploys code and watches a physical motor respond to a button press, something changes. Programming stops being abstract. Students start with Java fundamentals, variables, loops, and methods, learned in the context of real hardware rather than contrived textbook exercises.

Within weeks, students are writing driver-control programs that move motors and servos through a gamepad. They learn to read telemetry, interpret encoder counts, and debug by reasoning through what the code should be doing versus what the robot is actually doing.

Java BasicsMotor ControlIDE SetupTelemetryDebuggingDriver Control
ArcadeDrive.java 
public class ArcadeDrive extends CommandBase {
    private Drivetrain drivetrain;
    private DoubleSupplier x, y, rx;

    public ArcadeDrive(Drivetrain drivetrain,
                       DoubleSupplier x,
                       DoubleSupplier y,
                       DoubleSupplier rx) {
        this.drivetrain = drivetrain;
        this.x = x;
        this.y = y;
        this.rx = rx;
        addRequirements(this.drivetrain);
    }

    @Override
    public void execute() {
        drivetrain.updateTeleOpDrive(
            -x.getAsDouble(),
             y.getAsDouble(),
            -rx.getAsDouble(),
            true
        );
    }
}

What students learn first

Variables & Data Types

Primitives, objects, arrays, and when to use each. Students learn type safety by hitting real bugs, not reading about them.

Control Flow

Conditionals, loops, and switch statements. Applied immediately to sensor thresholds, motor ramping, and game-state logic.

Methods & Classes

Breaking code into reusable pieces. Students write their own utility methods and learn why good naming matters under pressure.

Object-Oriented Design

Inheritance, interfaces, and polymorphism. Each robot subsystem becomes a class; students see OOP solve real organization problems.

Debugging

Reading stack traces, using breakpoints, adding telemetry. Students learn to diagnose problems systematically instead of guessing.

IDE Proficiency

Code completion, refactoring tools, project structure, build systems. Students work in the same environments as professional engineers.

Turret.java 
public final static double kP = 1d / 600;
public final static double kD = -0.00002;

/**
 * Makes the turret face the goal.
 * Reads fresh pose data, computes the
 * absolute angle, then commands PD control.
 */
public void faceGoal() {
    aimer.periodic();
    double absoluteTurn =
        aimer.getTurretYawToGoal(false);
    setAngle(absoluteTurn);
}

public void setAngle(double angle) {
    angle = convertToNormal(angle);
    currentRotDeg = angle;

    if (angle <= MAX_ANGLE) {
        turretMotor.rotateToAngle(
            angle + offset, GEAR_RATIO, true);
    } else {
        turretMotor.rotateToAngle(
            angle - 360 + offset, GEAR_RATIO, true);
    }
}

02 / The Machine Thinks

Autonomous code. Sensor integration. Encoder control.

Autonomous programming is where software engineering becomes genuinely hard, and genuinely rewarding. Students write code that makes decisions without a human driver: navigate to a target, detect a game element, score it, and return to position, all on the first try.

This requires integrating sensors: encoders for distance, IMU for heading, color sensors for game element detection. Students learn PID control basics, why simply setting motor power is not good enough, and how feedback loops smooth the jerky motion that costs points at competition.

Autonomous RoutinesEncoder ControlIMU / GyroPID BasicsState MachinesGit

Control theory and sensor principles

PID Control

Proportional, integral, and derivative control. Students tune feedback loops to hold positions, follow paths, and maintain target speeds.

Encoder Integration

Translating raw encoder ticks into distance, velocity, and position. The foundation of every closed-loop system on the robot.

IMU & Gyroscope

Heading measurement and drift correction. Students use inertial data for field-centric driving and autonomous turning.

State Machines

Modeling complex sequences as discrete states with defined transitions. The pattern behind every reliable autonomous routine.

Sensor Fusion

Combining data from multiple sensors to get a better answer than any single sensor alone. Odometry, vision, and IMU working together.

Motion Profiling

Trapezoidal and S-curve profiles for smooth acceleration. Students learn why velocity planning matters for consistent autonomous performance.

03 / Competition Code

Vision. Motion profiles. Architecture that holds up under pressure.

By competition season, students write code that professional engineers would recognize as well-structured. Command-based architecture, subsystem abstraction, AprilTag detection for field element targeting, motion profiling for smooth autonomous movement. These are real software engineering patterns.

Students also learn the discipline that matters at 7 AM before a match: code that is readable, testable, and does not surprise you. Reviews, documentation, version control on GitHub. The practices that separate code that works in the lab from code that works on the field.

Computer VisionAprilTagsMotion ProfilingCode ArchitectureGitHubCode Review
BlueTeleOp.java 
/* default commands */
drivetrain.setDefaultCommand(new ArcadeDrive(
    drivetrain,
    () -> driver.getLeftX() * dir,
    () -> driver.getLeftY() * dir,
    () -> driver.getRightX()
));

hood.setDefaultCommand(new RunCommand(
    () -> hood.setPosition(aimer.getHoodAngleByDistance())
));

shooter.setDefaultCommand(new RunCommand(
    () -> shooter.setRPM(getSpeed())
));

/* Automatic Triggers */
new Trigger(intake::isBeamBroken)
    .and(new Trigger(() -> !indexer.isFull()))
    .whenActive(
        indexer.setCurrentSlotColorCmd()
            .andThen(indexer.rotate120Cmd(false))
    );

new Trigger(indexer::isFull)
    .whenActive(kicker.pushBall());

Software engineering practices

Command-Based Architecture

Subsystems own hardware, commands define behavior, and a scheduler manages conflicts. The industry-standard pattern for robot software.

Version Control with Git

Branching, merging, pull requests, and code review. Every change is tracked, and students learn to collaborate on a shared codebase without stepping on each other.

Computer Vision

OpenCV, AprilTag detection, and camera-based localization. Students process real video feeds to identify targets and compute field position.

Code Review Culture

No code ships without a second pair of eyes. Students learn to give and receive constructive feedback, and to write code that others can understand.

Modular Design

Separating concerns so that a change to the intake does not break the drivetrain. Students learn to design systems that can be tested and modified independently.

Documentation

Javadoc, inline comments where they matter, and engineering notebooks. Students learn that undocumented code is a liability, especially at 7 AM on competition day.

What the code actually looks like

A complete autonomous routine.

Every line written by students. No templates, no copy-paste. Built from scratch each season for the new game challenge.

TopAutoRed18.java
18-point autonomous routine
Start
Init Subsystems
Drivetrain, Shooter, Turret, Hood,
Intake, Indexer, Limelight
Parallel
followPath("scorePreload")
shooter.rampUp(1950)
shootBalls()
x4 cycles
Parallel
followPath + intake
kickerRetract()
openGate() + wait 1400ms
Parallel
followPath("score")
shooter.rampUp(2150)
shootBalls()
Parallel
followPath("pickUpTop") + intake
shootBalls()
End

Industry Tools

Professional tools, from day one.

Not toy IDEs or simplified learning environments. The real tools that engineers use at work.

Java

Primary language for robot code across both FTC and FRC. The same language used at Google, Amazon, and every major Android app.

IDEs

Industry-standard development environments. Students use the same tools as professional software engineers.

Git & GitHub

Every code change is committed, branched, and reviewed. Students graduate knowing real version control workflow.

OpenCV

The most widely used computer vision library in the world, powering everything from self-driving cars to medical imaging.

Competition Stack

Competition hardware and software.

The platforms students use to build, deploy, and compete with their robots.

Robot SDKs

Hardware abstraction layers that turn motors, servos, and sensors into clean Java APIs for robot control.

Control Systems

On-robot computers that run student code. Students flash firmware, configure hardware, and debug wirelessly.

Telemetry

Real-time data streams from the robot during matches. Students learn to instrument their code and debug under pressure.

Ready to write your first robot program?

No prior programming experience needed. We start from zero and build to competition-ready code.

Apply Now Explore Mechanical