Newton's Second Law

The law

The net force on an object equals its mass times its acceleration.

F = ma

Or, more fundamentally:

F = dp/dt

where p = mv is momentum. For constant mass, dp/dt = m·dv/dt = ma. For variable mass (rockets, raindrops), the dp/dt form is needed.

Force is measured in newtons: 1 N = 1 kg·m/s² (the force that gives 1 kg an acceleration of 1 m/s²).

It's a vector equation

F and a are both vectors. The acceleration is in the SAME direction as the net force. The magnitude is force divided by mass.

For multiple forces, vector-sum them all:

ΣF = F1 + F2 + F3 + ... = ma

In components:

ΣFx = max
ΣFy = may
ΣFz = maz

Worked examples

Scenario	Force	Mass	Acceleration
Push a 50 kg cart with 100 N	100 N	50 kg	2 m/s²
Drop ball (free fall)	mg = 9.8 N (1 kg)	1 kg	9.8 m/s² (= g)
Car brakes 1500 kg from 25 m/s to 0 in 5s	F = ma = 1500 × 5 = 7,500 N	1500 kg	5 m/s² (deceleration)
Rocket thrust 30 kN, mass 1000 kg (in space)	30,000 N	1000 kg	30 m/s²
Tennis ball impact, 0.1 s, F = 200 N	200 N	0.058 kg	3,448 m/s² (~350 g)
Apple falling toward Earth and Earth toward apple	mg (apple); same on Earth (3rd law)	Both	Apple: 9.8 m/s². Earth: ~10⁻²⁵ m/s²

Momentum form: F = dp/dt

For variable-mass systems, F = ma is incorrect. The right form is:

F = dp/dt = d(mv)/dt

For a rocket — gas exits at velocity v_e, with mass flow rate dm/dt. The thrust is:

F_thrust = v_e × |dm/dt|

The rocket equation (Tsiolkovsky, 1903):

Δv = v_e × ln(m_initial / m_final)

This is why rockets use the highest-velocity exhaust (chemical rockets ~4500 m/s, ion drives ~30,000 m/s) — Δv is logarithmic in mass ratio but linear in v_e.

Free-body diagrams

Solving F = ma problems requires identifying ALL forces acting on the object. Draw a free-body diagram:

1. Draw the object as a dot or simple shape.
2. Draw an arrow for EACH force acting on it (gravity, normal, friction, applied, tension, etc.).
3. Choose convenient axes (often along the direction of motion or along the surface).
4. Decompose each force into components along the axes.
5. Sum forces in each direction. Apply F = ma in each direction.
6. Solve for unknowns.

Example — block on inclined plane (angle θ, mass m, frictionless):

Forces: gravity (mg, down), normal (N, perpendicular to surface)
Along surface: ΣF = mg sin θ → a = g sin θ (down the slope)
Perpendicular: ΣF = N - mg cos θ = 0 → N = mg cos θ

JavaScript — F = ma simulator

// Apply F = ma to a particle in 2D
class Particle {
  constructor(x, y, vx, vy, mass) {
    this.x = x; this.y = y;
    this.vx = vx; this.vy = vy;
    this.mass = mass;
  }
  
  // Step: integrate Newton's 2nd law for a small time dt
  step(dt, fx, fy) {
    const ax = fx / this.mass;
    const ay = fy / this.mass;
    this.vx += ax * dt;
    this.vy += ay * dt;
    this.x += this.vx * dt;
    this.y += this.vy * dt;
  }
}

// Projectile: gravity is the only force
const ball = new Particle(0, 0, 20, 30, 0.5); // mass 0.5 kg
const g = 9.81;
const dt = 0.01;
let t = 0;
while (ball.y >= 0 || t < 0.01) {
  ball.step(dt, 0, -ball.mass * g); // F = -mg (downward)
  t += dt;
}
console.log(`Range: ${ball.x.toFixed(2)} m, time of flight: ${t.toFixed(2)} s`);

// Rocket equation
function rocketDeltaV(massInitial, massFinal, vExhaust) {
  return vExhaust * Math.log(massInitial / massFinal);
}

// Saturn V first stage: m_initial = 2.97M kg, m_final = 750K kg, v_e ~ 2580 m/s
console.log(`Saturn V first stage Δv: ${rocketDeltaV(2.97e6, 750e3, 2580).toFixed(0)} m/s`);
// ~3,540 m/s (gets close to orbital velocity for first stage)

Python — same with NumPy

import numpy as np

def simulate(x0, v0, mass, force_fn, dt=0.01, t_max=10, ground=0):
    """Simulate F=ma. force_fn(t, pos, vel) returns force vector."""
    x = np.array(x0, dtype=float)
    v = np.array(v0, dtype=float)
    t = 0
    trajectory = [x.copy()]
    while t < t_max and x[1] >= ground:
        F = force_fn(t, x, v)
        a = F / mass
        v += a * dt
        x += v * dt
        t += dt
        trajectory.append(x.copy())
    return np.array(trajectory), t

# Projectile in gravity
projectile, t_flight = simulate(
    x0=[0, 0], v0=[20, 30], mass=0.5,
    force_fn=lambda t, x, v: np.array([0, -0.5 * 9.81])
)
print(f"Range: {projectile[-1, 0]:.2f} m in {t_flight:.2f} s")

Where Newton's second law shows up

• Mechanics — universal. Every projectile, collision, orbit, and structural load uses F = ma. The foundational equation of classical physics.
• Engineering. Bridge design (forces from cars, wind), aerospace (thrust = ma for rockets), automotive (braking, acceleration), structural analysis.
• Simulation and animation. Game physics engines (Unity, Unreal) integrate F = ma at each frame. Particle systems, ragdoll physics, fluid simulations all reduce to F = ma.
• Robotics and control. Robot arm dynamics — torques produce angular accelerations. Quadrotor drones — thrust vectoring controlled by F = ma.
• Astrodynamics. Spacecraft trajectories, orbit transfers, planetary motion — all integrated F = ma over time.
• Sports physics. Ball trajectories, Magnus effect on spinning balls, friction in skiing/skating.
• Pre-relativity benchmark. When Einstein invented special relativity, F = ma was extended to F = d(γmv)/dt. The new equation reduces to F = ma at low speeds.

Common mistakes

• Forgetting it's a vector equation. F = ma in components — Fx = max, Fy = may. Confusing magnitudes with components is the #1 error.
• Using mass times velocity instead of mass times acceleration. F = ma, not F = mv. Force gives acceleration, not velocity directly.
• Ignoring some forces. Always inventory ALL forces — gravity, normal, friction, applied, tension, drag, buoyancy, etc. Free-body diagrams catch missing forces.
• Wrong sign convention. If you choose right = positive, friction on a rightward-moving object is NEGATIVE (opposes motion). Get the signs right or your sign of acceleration flips.
• Using F = ma for variable-mass systems. Rockets, raindrops accumulating mass — use F = dp/dt instead. F = ma loses the dm/dt term, giving wrong answers.
• Confusing weight with mass. Weight = mg (force). Mass is intrinsic (kg). On Mars, weight is 38% of Earth, but mass is unchanged. F = ma uses mass, not weight.