Electronic teams

The historical question

Electronic components accelerated operations, but representation, sequencing, debugging, I/O, and mapping a mathematical method onto hardware remained difficult programming work performed across large teams.

A computer’s capability is the joint product of device physics, architecture, mathematical method, programming, operation, and maintenance.

The computation includes the operating process

Use Euler’s method as a small example of turning mathematics into an executable procedure. For y′ = y, y(0) = 1, choose a step h = 0.1 and update y_next = y + h y. The first two steps give 1.1 and 1.21. A machine executing this requires numerical representation, arithmetic operations, sequencing, storage, and a way to inspect results. A mathematical recurrence does not supply those facilities automatically.

Errors can enter at different boundaries. The numerical method approximates continuous evolution. Finite representation rounds values. A wiring or instruction error may use an old value incorrectly. An input error may change the initial condition. These failures need different tests. Compare against a known solution, reduce the step size, trace an individual update, and verify input records rather than treating every discrepancy as hardware unreliability.

Early electronic computing was consequently team work. Designing devices, organizing memory and control, translating a method, configuring execution, and maintaining equipment were distinct contributions. Historical accounts should use operational artifacts and records to recover that division of labor. Performance claims also need a task and baseline: arithmetic rate is not the same as elapsed time to obtain a verified answer.

What the evidence does not establish

Priority claims depend on definitions such as electronic, programmable, digital, general-purpose, completed, and operational. State the scope instead of declaring one “first computer.”

Reconstruction exercise

Compute two Euler steps with h = 0.2. Identify one discretization error and one programming error that could occur.

Worked solution

Starting at 1 gives 1.2, then 1.44. The approximation differs from the exact continuous solution because finite steps replace the derivative’s continuous evolution. Accidentally adding h instead of h×y is an implementation error in the update rule. Reducing h can address approximation error, but cannot be relied on to repair an incorrect instruction. Test the formula and the numerical method separately.

Test the limits and transfer the idea

1. Numerical calculation · allow 30 minutes

Separate discretization error from an execution fault

For y′=y and y(0)=1, approximate y(1) with forward Euler using h=0.5 and h=0.25. Use e≈2.718281828 for the exact value. Calculate both results and absolute errors. A log from the quarter-step run shows 1, 1.25, 1.5625, 1.8, 2.25. Identify the first step inconsistent with the recurrence and explain why its discrepancy is not ordinary discretization error.

Get a starting hint

Under exact arithmetic every step multiplies the previous value by 1+h.

Compare your reasoning with the worked solution

With h=0.5, two steps give 1.5²=2.25, with error about 0.468281828. With h=0.25, four steps give 1.25⁴=2.44140625, with error about 0.276875578. The logged transition from 1.5625 should produce 1.953125, not 1.8, so it first violates the specified recurrence at the third update. Discretization error compares a correctly executed discrete method with the continuous equation; this log instead suggests a computation, recording or explicitly unstated rounding change. A smaller step is a diagnostic, not proof that every discrepancy is hardware failure. Smithsonian artifacts and collected histories document people and machines; these invented calculations demonstrate how mathematical method, execution and evidence must be checked separately.

Check your reasoning

• Computes both approximations and errors at the same final time.
• Locates the first recurrence violation.
• Separates numerical-method error from execution or recording error.

2. State trace · allow 25 minutes

Sequential writes can change simultaneous equations

A toy integrator uses simultaneous updates x_next=x+0.1y and y_next=y−0.1x, starting at (1,0). Compute two steps using old values for both equations. Then compute two steps when a programmer overwrites x before calculating y from the new x. Show a temporary-variable implementation that preserves the intended method and identify what an operational trace must record to reveal the error.

Get a starting hint

The equations refer to one old state, not a mixture of old and updated values.

Compare your reasoning with the worked solution

Correct steps are (1,−0.1), then (0.99,−0.2). With in-place x first, the first step coincides, but the second gives x=0.99 and y=−0.1−0.1×0.99=−0.199. A correct implementation saves old_x=x and old_y=y, then assigns x=old_x+0.1×old_y and y=old_y−0.1×old_x. An operational trace should record inputs to each arithmetic operation or enough intermediate state to reconstruct which version of x was read. Recording only the final displayed values at low precision can hide the difference. This is a modern teaching recurrence, not an assertion about an actual ENIAC program. It illustrates why programmers, mathematical analysts and operators contribute distinct evidence to a claim that a machine computed the intended result.

Check your reasoning

• Computes both two-step trajectories.
• Preserves old values explicitly in the repair.
• Names trace detail needed to expose the dependency error.

Check your understanding

Why can a fast arithmetic unit still yield a slow calculation?

• Preparation, I/O, debugging, and verification also consume time
• Arithmetic speed has no effect on any program
• Every task uses the same number of operations

Explanation

Starting at 1 gives 1.2, then 1.44. The approximation differs from the exact continuous solution because finite steps replace the derivative’s continuous evolution. Accidentally adding h instead of h×y is an implementation error in the update rule. Reducing h can address approximation error, but cannot be relied on to repair an incorrect instruction. Test the formula and the numerical method separately.

Sources and further reading

• Human Computer Project: Smithsonian American Women’s History Museum
• ENIAC artifact: Smithsonian Institution