Ethical and Social Issues Around Data Collection - AP Computer Science A

SECTION 1

Historical Context & Motivation

Every time a Java program stores user input in an ArrayList or writes records to a file, it participates in data collection—a practice as old as computing itself, yet one whose ethical dimensions have grown exponentially with the scale of modern systems. In the early days of mainframes, data collection was limited to census bureaus and large corporations; today, even a simple mobile app may aggregate location, biometric, and behavioral data from millions of users. The history of data ethics is therefore inseparable from the history of computing power: as storage became cheaper and networks faster, the questions of who collects data, how it is stored, and who benefits from it became urgent social concerns.

1970 • Fair Credit Reporting Act

The United States passed the FCRA, one of the first laws governing how personal data in electronic databases could be collected, shared, and corrected—establishing the idea that individuals have rights over their stored information.

1995 • EU Data Protection Directive

The European Union adopted Directive 95/46/EC, requiring that personal data be collected only for specified, legitimate purposes—a principle that would later evolve into the GDPR.

2013 • Snowden Revelations

Edward Snowden disclosed mass surveillance programs, sparking global debate about government data collection and reigniting public interest in digital privacy.

2018 • GDPR & Cambridge Analytica

The EU's General Data Protection Regulation took effect, while the Cambridge Analytica scandal demonstrated how data collected via social platforms could be weaponized for political manipulation.

2023 • AI Training Data Debates

Large language models trained on web-scraped data raised new questions about consent, copyright, and the ethics of using publicly available information at scale.

This timeline reveals a recurring pattern: technology outpaces regulation, a crisis exposes the gap, and society scrambles to catch up. As an AP Computer Science A student, you are learning to build the very systems that collect and process data. The central question this lesson addresses is: What responsibilities do programmers bear when their code collects, stores, and processes personal information?

SECTION 2

Core Principles of Data Ethics

Data ethics rests on a small number of foundational principles that appear across legal frameworks, professional codes, and academic literature. These principles apply whether you are building a student grade tracker in Java or designing a distributed database for a Fortune 500 company. Understanding them gives you a lens through which to evaluate any data-handling design decision.

Informed Consent

Users must be clearly told what data is collected and how it will be used before collection begins. Consent must be voluntary, specific, and revocable.

Data Minimization

Collect only the data strictly necessary for the stated purpose. Storing unnecessary fields—like ethnicity for a calculator app—introduces risk without benefit.

Transparency & Accountability

Organizations must document what data they hold, who can access it, and how long it is retained. When breaches or misuse occur, clear accountability mechanisms must exist.

Security & Integrity

Collected data must be protected against unauthorized access, alteration, or loss. In Java, this means proper encapsulation, access modifiers, and secure storage practices.

Equity & Non-Discrimination

Algorithms trained on biased data can perpetuate or amplify discrimination. Developers must audit data sets and outputs for disproportionate impact on protected groups.

SECTION 3

The Data Collection Lifecycle

Ethical concerns arise at every stage of the data collection lifecycle. The diagram below maps the journey of data from initial collection through storage, processing, sharing, and eventual deletion—highlighting the ethical checkpoint that should be evaluated at each stage.

Each stage of the lifecycle—collection, storage, processing, sharing, and deletion—introduces distinct ethical questions that developers must proactively address.

Notice that deletion is often the most neglected stage. In Java programs, removing an element from an ArrayList does not guarantee the data is unrecoverable—the JVM's garbage collector may not immediately reclaim the memory, and if the data was serialized to disk, file deletion alone may leave recoverable traces. Ethical data handling therefore demands attention not just to how data enters a system, but to how it is permanently and verifiably removed when it is no longer needed.

SECTION 4

How Data Collection Issues Manifest in Code

For AP Computer Science A, the connection between ethics and code is concrete. When you design a class that stores user data, your choice of access modifiers, data structures, and methods directly determines whether personal information is protected or exposed. Consider a Student class that stores grades in an ArrayList<Integer>. If the list is declared public, any class in the project can read, modify, or leak that data. Making the field private and providing controlled accessor methods is not just good object-oriented design—it is an ethical safeguard that enforces the principle of data minimization at the code level.

Encapsulation as an Ethical Mechanism

The encapsulation principle in Java—using private fields with public getters and setters—maps directly onto the ethical principle of access control. A getter that returns a defensive copy of a mutable collection prevents external code from altering the original data, embodying the security and integrity principle. Similarly, a setter that validates input before storing it ensures data quality and prevents injection of malicious values.

Aliasing and Unintended Data Exposure

Aliasing occurs when two reference variables point to the same object in memory. In the context of data ethics, aliasing is dangerous because it creates unintended data exposure. If a getGrades() method returns a direct reference to the internal ArrayList, any caller can modify the student's grades without going through validation. This is the programming equivalent of handing out unrestricted copies of a confidential file—violating both security and accountability.

ℹ

AP EXAM CONNECTION

Two collaborators adjust one blue articulated model while a second model stands apart. Two variables can provide access to one shared object. Copying a reference creates another access path; it does not duplicate the object.

Two separate list containers point from corresponding slots to the same mutable Box object. Copying the list creates a separate container while copying its element references. Both lists can still reach the same mutable Box. String and Integer values are immutable, so those elements cannot be mutated through either list.

SECTION 5

Algorithmic Bias and Social Impact

When data stored in arrays and lists feeds algorithms that make decisions—loan approvals, college admissions, hiring—the quality and representativeness of that data becomes a matter of justice. Algorithmic bias occurs when systematic errors in data collection or processing lead to unfair outcomes for specific demographic groups. Even a well-intentioned sorting algorithm can produce discriminatory results if the underlying data reflects historical inequities.

Bias enters at the data source, is encoded during collection, and is amplified by the algorithm. Mitigation requires intervention at every stage.

A well-documented example is Amazon's experimental hiring algorithm, which was trained on ten years of resumes. Because the tech industry historically employed more men, the algorithm learned to penalize resumes containing the word "women's" (as in "women's chess club"). The data stored in the training collection was technically accurate—it reflected reality—but that reality was shaped by decades of gender disparity. The lesson for AP CSA students is that correct code operating on biased data still produces harmful results.

Group A has population 80 and 16 recorded; group B has population 20 and 8 recorded. Capture rates are 20% and 40%, and observed shares are 16/24 and 8/24. Suppose group A contains 80 people and group B 20. Recording 16 from A and 8 from B gives capture rates of 20% and 40%; the recorded sample is two-thirds A and one-third B. Compare these denominators before explaining why representation differs.Open full diagram

SECTION 6

Worked Example: Designing an Ethical Data Class

Suppose you are asked to design a PatientRecord class for a hospital application. The class must store a patient's name, age, and a list of diagnoses. Walk through the ethical design decisions step by step.

Worked example

1
Step 1 — Apply Data Minimization

Determine which fields are strictly necessary. The prompt specifies name, age, and diagnoses. Resist the temptation to add fields like ethnicity, income, or insurance provider unless they serve a documented medical purpose. Each additional field increases the attack surface and the potential for discriminatory use.

Fields: private String name, private int age, private ArrayList<String> diagnoses
2
Step 2 — Enforce Encapsulation

All instance variables must be private. Provide getters that return defensive copies of mutable objects. The getDiagnoses() method should return new ArrayList<>(diagnoses) to prevent aliasing that could let external code tamper with medical records.

public ArrayList<String> getDiagnoses() { return new ArrayList<>(diagnoses); }
3
Step 3 — Validate Input in Setters

The setAge(int age) method should reject invalid values (negative numbers, unreasonably high ages). This ensures data integrity—corrupt data can lead to incorrect medical decisions.

public void setAge(int age) { if (age >= 0 && age <= 150) this.age = age; }
4
Step 4 — Control Access to Sensitive Methods

A method like addDiagnosis(String d) should be available only to authorized classes. While Java's access modifiers don't replicate full role-based security, you can use package-private access or design patterns (like a mediator) to restrict who calls sensitive methods. Document the intended access policy in Javadoc comments.

Use /* package-private */ access or guard methods with runtime checks.
5
Step 5 — Plan for Deletion

Include a clearAllData() method that nullifies all fields and clears the ArrayList. This supports the "right to be forgotten" and ensures that when a patient requests deletion, the program has a mechanism to comply.

public void clearAllData() { name = null; age = 0; diagnoses.clear(); }

A cleared local screen sits beside records retained along a data-sharing trail. Clearing a local list affects that list’s defined scope. Copies retained by recipients or backups follow their own retention and deletion processes.

A local clearAllData operation empties its own record while separate recipient and backup records remain. Suppose clearAllData() removes data in the local object. Recipient and backup copies remain separate objects or records and require their own deletion steps. Clearing fields and garbage collection do not by themselves securely erase every retained copy.

SECTION 7

Benefits vs. Risks of Data Collection

Data collection is not inherently harmful—it powers medical research, navigation systems, and personalized education. The ethical challenge lies in balancing societal benefit against individual risk. The table below contrasts the key benefits and risks, helping you evaluate tradeoffs in system design.

Dimension	Benefit	Risk
Health	Aggregated patient data accelerates drug discovery and epidemic tracking	Leaked medical records can cause discrimination in insurance and employment
Education	Learning analytics personalize instruction and identify struggling students early	Student surveillance can chill intellectual exploration and disproportionately monitor minorities
Commerce	Recommendation engines improve user experience and reduce search costs	Behavioral profiling enables manipulation, price discrimination, and filter bubbles
Public Safety	Location data aids disaster response and traffic optimization	Mass surveillance erodes civil liberties and enables authoritarian control

Benefits vs. risks across four domains of data collection

SECTION 8

Connection to Advanced Theory & Regulation

The principles you learn in AP CSA form the foundation for more advanced topics in computer science ethics, data governance, and policy. Understanding where introductory concepts connect to professional and legal frameworks will help you see why these ideas are tested on the exam and why they matter in your career.

AP CSA Concept	Advanced / Professional Extension
Private fields and encapsulation	Role-based access control (RBAC), encryption at rest, zero-trust architecture
Defensive copies of ArrayLists	Immutable data structures, copy-on-write semantics in concurrent systems
Data minimization in class design	GDPR Article 5 (purpose limitation), differential privacy, k-anonymity
Bias in data stored in collections	Fairness-aware machine learning, disparate impact analysis, algorithmic auditing
clearAllData() method for deletion	GDPR "right to erasure" (Article 17), CCPA deletion requests, cryptographic erasure

From AP CSA concepts to professional data ethics

As you move beyond AP CSA, you will encounter formal frameworks like differential privacy, which adds carefully calibrated noise to data so that aggregate statistics are useful but individual records remain unidentifiable. You will also engage with ethical AI governance frameworks that require impact assessments before deploying any system that makes automated decisions about people. The core intuition, however, remains what you are learning now: every line of code that touches personal data carries moral weight.

SECTION 9

Practice Problems

Question 1: CONCEPTUAL

A programmer designs a UserProfile class for a music-streaming app. Which of the following fields would violate the principle of data minimization?

A. private String email
B. private ArrayList<String> favoriteSongs
C. private String socialSecurityNumber
D. private String username

Show answer (C)

C is correct. A social security number has no legitimate purpose in a music-streaming application, making it a violation of data minimization—collecting data beyond what is needed for the stated service. A is incorrect because an email is necessary for account authentication and communication. B is incorrect because favorite songs are central to the app's core functionality (personalized recommendations). D is incorrect because a username is essential for identification within the platform.

Question 2: BASIC CALCULATION

Consider the following code:

public class Student {
  private ArrayList<Integer> grades;
  public Student() { grades = new ArrayList<>(); }
  public ArrayList<Integer> getGrades() { return grades; }
}

What is the primary ethical concern with the getGrades() method?

A. It uses an ArrayList instead of a standard array, which is less efficient.
B. It returns a direct reference to the private list, allowing external code to modify a student's grades without authorization.
C. It does not sort the grades before returning them.
D. It stores grades as Integer objects instead of primitive ints.

Show answer (B)

B is correct. Returning the direct reference creates an alias: the caller and the Student object share the same ArrayList. External code can add, remove, or change grades without going through any validation—a violation of data security and integrity. The fix is to return new ArrayList<>(grades). A is incorrect because the choice of ArrayList vs. array is a performance consideration, not an ethical one. C is incorrect because sorting is unrelated to data protection. D is incorrect because autoboxing is a language feature, not a security vulnerability.

Question 3: INTERMEDIATE

A school district uses an algorithm that processes student attendance data (stored in an ArrayList<StudentRecord>) to flag students at risk of dropping out. Students from lower-income zip codes are flagged at disproportionately high rates. Which combination of ethical principles is most directly at stake?

A. Informed consent and data deletion
B. Equity/non-discrimination and transparency/accountability
C. Data minimization and encryption
D. Security/integrity and data deletion

Show answer (B)

B is correct. The disproportionate flagging of students from lower-income areas is a clear equity and non-discrimination issue—the algorithm may be encoding socioeconomic bias. Transparency and accountability are also at stake because stakeholders need to understand how the algorithm produces its flags to identify and correct the bias. A is incorrect because, while consent matters, it is not the primary concern when the output is discriminatory. C is incorrect because the problem is not about collecting too much data or encryption failure. D is incorrect because the issue is not unauthorized access or deletion, but biased processing.

Question 4: APPLIED

You are designing a HealthTracker class for a fitness application. The class stores a user's name and a list of daily step counts. (a) Write the class declaration with private instance variables and a constructor. (b) Write a getStepCounts() method that prevents aliasing. (c) Write a deleteAllData() method that supports the right to erasure. (d) In 3–5 sentences, explain why returning a defensive copy in part (b) is both a correctness measure and an ethical safeguard.

Show answer

(a)

public class HealthTracker {
  private String name;
  private ArrayList<Integer> stepCounts;
  public HealthTracker(String name) {
    this.name = name;
    this.stepCounts = new ArrayList<>();
  }
}

(b)

public ArrayList<Integer> getStepCounts() {
  return new ArrayList<>(stepCounts);
}

(c)

public void deleteAllData() {
  name = null;
  stepCounts.clear();
}

(d) Returning a defensive copy prevents external code from holding a reference to the internal ArrayList, which means callers cannot add, remove, or modify step counts without going through the class's own methods. From a correctness standpoint, this preserves the class invariant that only validated modifications reach the data. From an ethical standpoint, it enforces access control—a critical component of data security—ensuring that health data cannot be tampered with by unauthorized parts of the program. This is especially important for health data, which is classified as sensitive personal information under most privacy regulations.

Question 5: CRITICAL THINKING

A social media company stores user posts in an ArrayList<Post>. After a user deletes their account, the company retains the posts for machine-learning training purposes. (a) Identify which ethical principle(s) this practice potentially violates and explain why. (b) Propose a technical solution at the Java class level that would better align the system with ethical data handling. (c) Describe one scenario where retaining data after account deletion might be ethically justified.

Show answer

(a) This practice violates informed consent because the user's act of deleting their account expresses a clear intent to remove their data, yet the company retains it for a different purpose. It also violates purpose limitation (a subset of data minimization): the data was originally collected for social sharing, not for training machine-learning models. (b) A deleteAccount() method could iterate through the ArrayList<Post>, call a method on each Post that nullifies the author field and strips personally identifiable information, then remove all Post objects associated with that user. If retention for ML is desired, the posts could first be anonymized (author set to null, metadata stripped) so no link to the original user remains. (c) If a law enforcement agency has issued a legal preservation order related to an ongoing investigation, the company may be legally required to retain the data regardless of the user's deletion request. In this case, legal compliance overrides the user's erasure right, though the data should still be access-restricted and deleted once the hold expires.