3.2 Impact of Program Design

3.2 Impact of Program Design

A program is never only code: once people use it, its design can change decisions, opportunities, costs, and culture. 3.2 Impact of Program Design asks the central question: What happens to people and communities when a computing system works—or fails—in the real world?

The required learning objective is 3.2.A: Explain the social and ethical implications of computing systems. The associated skill is 5.A: Explain how computing impacts society, economy, and culture. Together, they require more than making a program produce the correct output; they require examining who benefits, who may be harmed, and what responsibilities belong to the programmers who build it.

From Java design to community consequences

A design decision travels through a chain:

1. Program design: A programmer chooses data, rules, inputs, and outputs.
2. System behavior: The program classifies, calculates, recommends, or controls something.
3. Human use: People rely on the result to make choices.
4. Community impact: The system changes access, behavior, money, safety, or culture.
5. Ethical responsibility: Developers evaluate foreseeable benefits and harms.

For example, a calculator that converts a person’s weight between planets may appear harmless. Yet even this small program requires decisions about units, assumptions, input validation, and how results are communicated. A larger system—such as software used to rank applicants or distribute public resources—can magnify similar design choices across an entire community.

Worked example: Intergalactic Calculations

In the Intergalactic Calculations lab, a student creates a calculator that determines a user’s weight on different planets. The program may begin with a simple relationship: if a planet’s gravitational multiplier is stored as $g_p$, then a user’s planetary weight can be calculated as

$$ w_p = w_E \times g_p $$

where $w_E$ is the user’s weight on Earth.

A straightforward Java implementation might look like this:

double earthWeight = 150.0;
double marsMultiplier = 0.38;
double marsWeight = earthWeight * marsMultiplier;

System.out.println("Your weight on Mars: " + marsWeight);

The arithmetic is simple, but responsible programming requires further questions:

• Does the program clearly state whether the input is measured in pounds or kilograms?
• Does it reject impossible input, such as a negative weight?
• Does it explain that “weight” depends on gravity while mass does not?
• Does it label the output so users do not mistake $57.0$ for an Earth measurement?
• Can another programmer update the planetary multiplier without breaking the rest of the program?

A technically correct result can still create confusion if the interface hides assumptions. This illustrates an important principle: correctness is necessary, but it is not the whole ethical standard for a computing system.

Ethical programming means anticipating how a system may affect people, communicating limitations honestly, protecting users from avoidable harm, and taking responsibility for foreseeable consequences.

Computing’s broader impact

Computing affects three connected areas:

Area	Possible positive effect	Possible negative effect
Society	Faster access to services, communication, and medical information	Privacy loss, unequal access, or harmful automated decisions
Economy	New businesses, productivity, and career opportunities	Job displacement, market concentration, or hidden labor
Culture	New forms of music, art, collaboration, and expression	Misinformation, reduced privacy, or changes in how communities interact

The same technology can produce different outcomes for different groups. A translation system may expand access for many users while performing poorly for a less-represented language community. A recommendation system may help users discover useful information while also reinforcing narrow viewpoints. Evaluating impact therefore means asking not only “Does it work?” but also “For whom, under what conditions, and with what trade-offs?”

Ethical programming and AI use

A practical guide for ethical programming and AI use begins with five checks:

• Purpose: What problem is the system solving, and is that purpose beneficial?
• Data: What information is collected, and was it obtained and used appropriately?
• Fairness: Could the system systematically disadvantage a person or group?
• Transparency: Can users understand important assumptions and limitations?
• Accountability: Who investigates errors and repairs harm?

AI tools add special responsibilities. A programmer should not treat generated code as automatically correct, original, secure, or fair. AI-generated code must be read, tested, documented, and checked for inappropriate use of proprietary code or personal information.

Programming failures and their consequences

A programming failure may be a syntax error, a logic error, an incorrect assumption, or a mismatch between the system and its users. In a small classroom calculator, failure may produce a misleading number; in a widely deployed system, failure can affect safety, finances, access to services, or public trust.

The responsible response is not merely to say that “the computer made a mistake.” Programmers designed the rules, selected the data, and decided how the output would be used. Testing, clear documentation, input validation, and careful review reduce risk, while monitoring after release helps reveal harms that were not visible during development.

Named misconception — “If the output is mathematically correct, the program is ethical.”
A program can calculate accurately and still use unfair data, expose private information, conceal uncertainty, or encourage harmful decisions. Technical accuracy and ethical responsibility must be evaluated separately.

AP alignment and retrieval check

This topic develops Skill 5.A: Explain how computing impacts society, economy, and culture, and it directly supports CR7, the requirement concerning the impact of computing on society and culture. It also develops Computational Thinking Practice 5: Use Computers Responsibly by connecting hands-on Java design, writing, and testing to the consequences experienced by real users.

Retrieval check: A planet-weight calculator produces the correct numerical conversion but accepts negative input and never identifies its units. Name one technical weakness and one social or ethical consequence. A strong response identifies the input or communication failure and explains how it could mislead users or cause them to make an incorrect decision.