AP® Computer

Science Principles
Notes

Jesus Barrios
Author

AP® is a registered trademark of of the College Board, which is not affiliated with Dove’s Library and was not
involved in the production of, and does not endorse, this product.
Table of Contents
Create Task: Tips and Resources

Big Idea 1: Creative Development

Big Idea 2: Data

Big Idea 3: Algorithms and Programming

Big Idea 4: Computer Systems and Networks

Big Idea 5: Impact of Computing

 Create Task:
Tips and Resources

Return to Table of Contents

Create Task: Tips and Resources
The Create Task is an essential component of the AP Computer Science Principles
exam, designed to assess your ability to develop functional software. It focuses on
practical skills rather than complex theoretical knowledge. This section provides
guidance and examples to help you efficiently complete your task.

Overview of Requirements: Your task should involve creating an application that

includes:

1. User Input and Output: The app must allow for user interaction through
input and output mechanisms.
2. Data Storage: Implement a list or array to store multiple data items.
3. Function with Parameters: Develop at least one function that takes
parameters and performs operations such as iteration and conditional
checks.

Suggested Project Idea: For those looking to complete the task with a
straightforward project, consider building a simple calculator. This application
meets the criteria by involving user input, output, and basic data handling.

Key Elements to Include:

● User Interface: Ensure your application has clear input and output fields.
● Data Handling: Use a list or array to manage data within the app.
● Functional Operation: Include a function that accepts parameters. Within
this function, use a loop (e.g., a 'for' loop) to iterate through the list and
conditional statements (if/else) to handle different scenarios based on the
data.

Additional Tips:

● Ensure the user input can navigate through conditional statements

effectively.
● Focus on creating a clean and intuitive user interface to enhance usability.

Resources: For further examples and inspiration, review the sample CSP Create
Tasks available on the College Board website. These examples can provide a
clearer picture of what is expected and how to structure your project to meet the
AP criteria.

4
Create Task: Tips and Resources
Example of My Create Task Submission: Jumping Game

In the 2023-2024 school year, I developed a game where the gameplay involved
a dog that jumps when the player presses an arrow key, the space bar, or a
mouse button. This game was coded in JavaScript, showcasing effective use of
programming skills aligned with AP Computer Science Principles
requirements.

Key Components of the Game:

● User Input: The game responds to keyboard and mouse inputs, allowing
the dog to jump.
● Output: The game visually represents the character's jumps and displays
scores.
● Data Management: An array stores the scores, and a specific procedure
determines and displays the highest score achieved.

5
Create Task: Tips and Resources
Submitting Your Code to CollegeBoard

For an effective and organized submission of your code to the College Board,
consider using the following website:

● Code Print Tool: https://bakerfranke.github.io/codePrint/

○ Why Use It? This tool converts your code into a PDF file with several
enhanced features:
■ Color Coding: Helps distinguish different parts of the code for
better readability.
■ Line Numbers: Essential for referencing specific lines in your
explanations.
■ Highlighting: Allows you to mark important sections of your
code, which is particularly useful for parts that meet specific AP
criteria.

Important Note on Using External Resources

When incorporating any external resources in your project, proper citation is

crucial to maintain academic integrity and adhere to AP guidelines.

● Images and Code Snippets:

○ If you use images or code not created by you, ensure to include a
comprehensive citation. This should cover the title, author, source
name, date of access, and the URL of the source.

Example citation for code or external content:

/* Citation/Reference: [Title] By [Author] Accessed from [Source
Name] on [Date], URL: [https://example.com] */

6
Create Task: Tips and Resources
● Assistance from AI or Peers:
○ If your project involved assistance from AI tools or peers, it's
important to acknowledge this collaboration clearly within your code
comments.

Example of citing AI or peer assistance:

/*Citation/Reference: Artificial Intelligence was used to assist
in optimizing this function, in compliance with peer
collaboration guidelines.*/

○ Replace "Artificial Intelligence" with "peer" or "classmate" (keeping

them anonymous) if the assistance was from a person.

These practices not only ensure transparency but also help in upholding the
principles of fair use and academic honesty in your submissions. Always check
the latest AP guidelines and your school's policy on collaborative work to make
sure you're in compliance.

Acceptable Use of Generative AI Tools: Students are allowed to use

generative AI technologies as supplementary aids. These tools can assist in
understanding coding principles, developing code, and debugging. This use is
in line with the AP guidelines for peer collaboration in coding projects.
However, there are important considerations and responsibilities that come
with the use of such tools:

● Accuracy and Reliability: AI-generated code may be incomplete,

potentially biased, or contain errors. It might also introduce inefficiencies
or complexities that can complicate the execution and understanding of
the code.
● Student Responsibility: It is crucial for students to thoroughly review and
understand any code co-developed with AI tools to ensure its proper
functionality.
● Code Explanation: Students must be prepared to explain their code in
detail during the AP exam, demonstrating a deep understanding of the
work submitted, regardless of the use of AI in its development.

7
Create Task: Tips and Resources
Acceptable Programming Languages and Products: For the AP Computer
Science Principles course, students can choose from a wide range of
programming languages and development environments. Here is a list of
acceptable options, as mentioned on page 130 of the course materials:

● Programming Languages and Environments:

○ Alice
○ App Inventor
○ App Lab (Code.org)
○ EarSketch
○ Greenfoot
○ Java
○ JavaScript
○ LEGO Mindstorms EV3
○ Microsoft MakeCode
○ Processing
○ Python
○ Quorum
○ Scratch
○ Snap!
○ Swift
○ TI-Basic

Note: HTML alone is not sufficient, as it doesn't involve programming logic. It

can be used to display data but must be combined with JavaScript or another
approved language handling the logic.

8
 Big Idea 1:
Creative
Development

Return to Table of Contents

Big Idea 1: Creative Development
Introduction to Computing Innovations

Computing innovations are constantly evolving, driven by human creativity and the
ever-present desire to improve technology. These innovations can originate from virtually
anywhere, reflecting the diverse needs and challenges of society.

Examples of Computing Innovations:

● Crime Prevention: Technologies such as data mapping, tracking systems, and

biometric verification have revolutionized the way we address security and law
enforcement.
● Healthcare: Insurance companies utilize data analytics to assess providers and
determine the most effective care strategies.
● Engineering and Communications: Advances in computing have spurred innovation
in these fields, enhancing capabilities and efficiency.
● The Arts: New computing techniques have introduced revolutionary ways to blend
various media types, transforming artistic expression.

Not all innovations catch on immediately.

Impact of Computing on Other Fields:

Computing technology not only enhances functionality but also aids in modeling real-world
scenarios and predicting outcomes by analyzing different variables. This integration of
computing has contributed to increased creativity across multiple domains, including
medicine, engineering, communications, and the arts.

Hardware vs. Software

● Hardware: Refers to the physical components of a computing device, such as circuits,

chips, and keyboards.
○ CPUs, Hard drives, GPUs, Motherboards
● Software: Comprises the instructions and programs that command the hardware to
perform tasks.
○ Operating systems, Application software, Web browsers, Database systems

While both elements are crucial, the essence of most computing innovations lies in the
software, driving functionality and user interaction.

Moore's Law and Its Impact:

Moore's Law observes that the number of transistors on a microchip doubles approximately
every two years, while the cost of computers is halved. This principle has seen computers
evolve from large machines occupying up to 1000 square feet and weighing nearly 50 tons
to devices that fit comfortably in one's pocket. 10
Big Idea 1: Creative Development
Understanding Collaboration

Collaboration is an essential skill in the computing world, facilitating the pooling of

diverse perspectives, skills, and experiences to enhance the development and
execution of computing innovations. It helps in overcoming personal biases by
integrating varied viewpoints, which is crucial for creating universally effective and
inclusive technologies.

Scenario Demonstrating the Value of Collaboration:

Consider a health technology company developing an app to monitor heart health. If

the development team consists only of software engineers without input from
cardiologists, the app might not effectively address all medical needs or user
concerns. By collaborating with medical professionals, the engineers gain insights
into specific health requirements and user interfaces that are more appropriate for
patients and doctors, making the app more effective and user-friendly.

Benefits of Collaboration in Programming:

1. Skill Enhancement:
○ Group programming allows individuals to pair their strengths with others'
weaknesses, leading to a more robust and comprehensive product.
2. Increased Efficiency:
○ Multiple perspectives can streamline problem-solving processes and
introduce innovative solutions faster.
3. Learning and Development:
○ Collaboration is not just about completing tasks but also about personal
growth and development in communication, negotiation, and conflict
resolution.
4. Resource Sharing:
○ Combining different resources and talents from individuals enhances the
quality and scope of projects.
5. Remote Collaboration:
○ Modern tools like Google Docs, Zoom, and Slack enable programmers to
collaborate effectively regardless of geographical barriers, ensuring that
physical location is no longer a limitation.

11
Big Idea 1: Creative Development
Collaboration's Impact on Product Development:

The collective experience and expertise of a group often surpass what an individual
can achieve alone. This shared knowledge base leads to more creative solutions and
innovations, proving that the whole can indeed be greater than the sum of its parts.

Understanding Program Functions

A program, often referred to as software, is a collection of statements that instruct the

computer to perform specific tasks.

Example of Basic Program Function:

● Input: Receive the number 3.

● Task: Determine if the number is even or odd.
● Output: The program outputs "odd".

This example illustrates how a simple input can be processed to yield a specific
output, demonstrating the fundamental operation of a software program.

Introduction to Code Segments

A code segment refers to a collection of program statements that collectively

perform a specific task within a larger program. In the AP Computer Science
Principles exam, students may encounter code both in textual and graphical forms.
Here, we will present two examples of simple text-based code segments to
demonstrate basic input, process, and output operations.

//Input: A number

number ← 5

//Process: Calculating the

square of the number

square ← number * number

//Output: Display the square

of the number

DISPLAY(square)
12
Big Idea 1: Creative Development
The Importance of Collaboration in Debugging

Collaboration in programming is crucial as it brings multiple perspectives

to the table, which is especially helpful in identifying and resolving logical
errors. A fresh set of eyes can often spot mistakes that a programmer too
close to the code may miss. This collaborative effort enhances the
debugging process and increases the overall quality of the software.

Program Abstraction

Abstraction in programming allows users to interact with software

without needing to understand the underlying details of its operation.
This abstraction is essential for simplifying user experiences and focusing
on functionality rather than complexity.

Example of Program Input

Consider a smart home system that adjusts the lighting based on the
natural light input received through sensors:

13
Big Idea 1: Creative Development
Here’s a simple diagram illustrating the input and output process in a
typical application:

Input Process Output

Examples of Input: Keyboard typing, Mouse click, Sensor data

Examples of Process: Data calculation, User command interpretation
Examples of Output: Display information, Sound, Mechanical action

Basic Example of How a Program Uses Input to Trigger an Event

Example: Music Streaming App

● Input: User selects a song from the playlist.

● Process: The app receives the selection and retrieves the
corresponding audio file from its database.
● Event Trigger: The audio file is streamed, and the music begins to
play through the user’s device.

This example demonstrates how input (song selection) is processed by

the app to produce an output (music playback), providing a
straightforward illustration of how user interactions can control software
behavior.

14
Big Idea 1: Creative Development
Understanding the Development Process in Computing

The software development process can be visualized through various stages,

each critical to the creation of a functional and user-friendly application. This
process can be either orderly and planned or more exploratory, depending on
the project requirements.

The Iterative Development Process

1. Investigating and Reflecting: Initial research and brainstorming to

understand user needs and technical requirements.
2. Designing: Creating designs and mockups to visualize the application’s
layout and functionalities.
3. Prototyping: Developing a working model of the app to test design
concepts and basic functionality.
4. Testing: Rigorous testing to identify bugs and verify the app meets all
functional requirements.

Example of Iteration: After testing, you may discover that additional features
are necessary or certain functionalities are not user-friendly, prompting a
return to the "Investigating and Reflecting" phase to reconsider these aspects.
This cycle might repeat multiple times, refining the application until it meets
the desired standards or until development time expires.

The Incremental Development Process

● Process: This approach involves breaking down the software project into
smaller, manageable components or increments. Each part is developed,
tested, and finalized before moving on to the next, ensuring that each
component functions correctly as part of the whole.

Example of Incremental Development: For a large e-commerce platform, the

development could start with user registration and login processes. Once these
are fully operational, shopping cart functionalities might be added, followed by
payment processing modules. This method helps in isolating and resolving
errors more efficiently, simplifying the debugging process.

15
Big Idea 1: Creative Development
Understanding the Design Process

The design of a program involves thorough investigation to determine its requirements.

Since most programs are intended for users other than the developers themselves, it is
crucial to understand not only the technical constraints but also the needs and concerns of
the end-users.

Methods for Investigation:

● User Interviews: Engaging with potential users to gather insights about their needs
and preferences.
● Market Research: Analyzing similar applications to understand common features and
user expectations.
● Feedback Loops: Implementing initial designs with a small group of users to collect
feedback and make necessary adjustments.

Importance of Program Documentation

Program documentation plays a vital role in the development and maintenance of

software. It provides a detailed description of what a code segment, event, procedure, or the
entire program does, and explains how it was developed.

Benefits of Documentation:

● Memory Aid: Helps programmers recall their thought processes or decisions made
during development.
● Collaboration Support: Essential in team settings, allowing all members to
understand each part of the program.
● Maintenance and Updating: Facilitates future changes and debugging by providing a
clear understanding of the program’s functionality.

Forms of Documentation:

● Comments: Non-executable text within the code that explains functions, variables,
and algorithms. Comments are crucial for maintaining readability and do not impact
the runtime or speed of the program.
● External Documents: These might include requirement specifications, design
diagrams, and user manuals, providing broader context and guidelines for using and
modifying the program.

Example of Using Comments in AP Pseudocode

//This is a comment
16
Big Idea 1: Creative Development
Understanding the types of errors that can occur during programming is crucial for
developing efficient and reliable software. Additionally, how these errors are
documented varies based on the programming language and project requirements.
Below, we explore the three common types of programming errors along with
examples, and discuss documentation practices.

Program Documentation Practices

Documentation can vary significantly depending on the programming language and

the nature of the project. For the AP Computer Science Principles performance task,
you have the option to:

● Inline Documentation: Write comments directly in your code to explain

segments, logic, and decisions.
● External Documentation: Prepare a separate document detailing the
functionality and development process of your program, which can include
diagrams, descriptions, and summaries.

Importance of Flexible Documentation: Adapting your documentation to the

specific needs of the project and the preferences of your team or course
requirements is essential for clarity and maintainability.

Types of Program Errors

1. Logic Error:

● Description: A logic error occurs when there is a flaw in the algorithm that
causes the program to operate incorrectly or produce unintended results.

2. Syntax Error:

● Description: A syntax error occurs when the code violates the grammatical
rules of the programming language, leading to a failure in compiling or
interpreting the code.

3. Runtime Error:

● Description: A runtime error happens during the execution of the program,

often due to operations like division by zero, accessing invalid array indices, or
insufficient memory.

17
 Big Idea 2:
Data

Return to Table of Contents

Big Idea 2: Data
Bits and Data Representation

Introduction to Bits and Bytes:

● Bit: The smallest unit of data in computing, represented as either 0 or 1.

● Byte: Consists of 8 bits. For instance, the binary sequence 0110 1111 is an
example of 1 byte.

Binary Sequences: Binary sequences serve as the backbone of data

representation in digital systems. These sequences can encode a variety of data
types:

● Colors: Specific sequences represent different colors in digital images.

● Boolean Logic: Used in programming to handle true/false conditions.
● Lists and More: Virtually any data type used in computing can be
represented in binary form.

Complex Data Representation: Larger and more complex data types require
multiple bits. For example, a simple color in an image might need 24 bits - 8
bits for each of the red, green, and blue components.

Abstractions in Computing

Purpose of Abstractions: Abstractions simplify complex systems by showing

common features and hiding unnecessary details. This approach not only
clarifies the design but also enhances reusability and efficiency in coding.

Reducing Redundancy: Instead of repeating code, programmers create

functions or procedures that can be called multiple times. This practice not
only saves time but also reduces the potential for errors.

Example of Function Abstraction in Pseudocode:

19
Big Idea 2: Data
High-Level Programming Languages

Example of Basic Operation in a High-Level Language:

let sum = 3 + 5

Explanation of Abstractions in Programming Languages: Programming

languages serve as abstractions to simplify interactions with the computer.
They allow programmers to write code using human-readable commands
rather than binary machine code. Without these abstractions, programmers
would have to write programs in binary, which is incredibly complex and
error-prone.

High-level languages, which include languages like Python, Java, and

JavaScript, provide the greatest level of abstraction. They simplify coding and
debugging by managing many of the details related to machine interactions
internally.

Analog vs. Digital Data

Analog Data: Analog signals are continuous; they change smoothly over time.
Common examples of analog data include:

● Pitch and Volume of music, which vary continuously as a song plays.

● Colors in a painting, which blend without clear boundaries.
● Position of a sprinter during a race, which changes fluidly as the race
progresses.

Digital Data: Digital signals break information into discrete steps. By sampling
analog signals at regular intervals (samples), digital signals can closely
approximate their analog counterparts. The more frequent the sampling rate,
the more accurately the digital signal represents the analog signal.

20
Big Idea 2: Data
Understanding Variables and Data Types

Variables as Abstractions: In programming, a variable is an abstraction

that stores a value. While a variable can hold a single piece of data, it can
also store complex data types that contain multiple values.

Examples of Data Types:

● Integer: Whole numbers without a fractional component, e.g.,

a. let age = 30;
● Real Numbers (Floats): Numbers that include decimals, e.g.,
a. let height = 5.9;
● Boolean: True or false values, e.g.,
a. let isAdult = true;
● List (Array in JavaScript): An ordered collection of items, e.g.,
a. let colors = ['red', 'green', 'blue'];

21
Big Idea 2: Data
Understanding Integer Representation and Number Systems in
Programming

Integer Representation in Programming Languages

In many programming languages, integers are represented by a fixed

number of bits. This limits the range of values these integers can hold and
affects the mathematical operations performed on them.

Integer Overflow: Trying to store a number beyond this range can lead to
an overflow error, where numbers wrap around to negative values due to
exceeding the maximum limit:

In contrast, some programming languages like Python handle integers

more flexibly by allowing them to expand to use more bits as needed,
limited only by the available memory.

AP Exam Context: For the AP Computer Science Principles exam, it's

important to understand that, similar to Python, there is no fixed limit on
the size of numbers unless constrained by the computer's memory.

Number Systems and Conversions

Basics of Number Systems: Number bases such as binary, decimal, and

hexadecimal are fundamental in computing for data representation. For
the AP exam, you should be proficient in converting between binary and
decimal systems.

22
Big Idea 2: Data
Example of a Binary to Decimal Conversion:

Binary Number: 11110

Step-by-Step Conversion:

Write out the bit numbers:

11110

Assign decimal values to each position (from right to left, starting with
2^0):
1 1 110
16 8 4 2 1

Add the values where there is a '1':

16 + 8 + 4 + 2 = 30

The binary number 11110 converts to decimal 30.

Tutorial Explanation:

● Base System: Binary numbers use a base of two. Each position in a

binary number represents an increasing power of two, starting from
2^0 on the right and then 2^1 and so forth.
● Conversion Process: To convert binary to decimal, write down the
power of two that each position represents. Sum the values for
positions that contain a '1'. Ignore positions with a '0'.

23
Big Idea 2: Data
Converting from Decimal to Binary

Understanding how to convert decimal numbers to binary is a key skill for the
AP Computer Science Principles exam. Below, I'll repeat the strategy used for
binary to decimal conversion, but in reverse, showing how to convert decimal
numbers into binary.

Step-by-Step Conversion from Decimal to Binary:

Let's convert the decimal numbers 30, 15, 7, 5, 3, and 1 into binary:

1. Decimal Number: 30
○ Binary Representation: 11110
2. Decimal Number: 15
○ Binary Representation: 1111
3. Decimal Number: 7
○ Binary Representation: 111
4. Decimal Number: 5
○ Binary Representation: 101
5. Decimal Number: 3
○ Binary Representation: 11
6. Decimal Number: 1
○ Binary Representation: 1

Explanation:

● For each number, start from the largest power of two within the number.
For 30, I’d start from 2^4 because 2^5 is over 32 which is over, meaning it
won’t work.
● Write out the powers of two from the largest to the smallest. So from here,
we write out 16 8 4 2 1.
● Place a '1' over the powers of two that sum to the decimal number and '0'
where not needed.
● The sequence of '1's and '0's forms the binary representation.

24
Big Idea 2: Data
Adding Decimal and Binary Numbers

Adding Decimal and Binary:

● To add a binary number to a decimal, first convert the binary to

decimal using the previously mentioned strategy, then add the
decimals. If the final answer needs to be in binary, convert the
decimal sum back to binary.

Adding Binary to Binary:

● Convert both binary numbers to their decimal equivalents.

● Add the decimal numbers.
● Convert the result back to binary.

Understanding Various Errors

Overflow Errors

Overflow Error Explanation:

● Fixed Bit Representation: Many programming languages use a fixed

number of bits to represent integers.
● Maximum Value Formula: 2^n - 1 where n is the number of bits. This
formula gives the largest value that can be stored.
● Example: For an 8-bit system, the maximum value is 2^8 - 1 = 255.
Trying to store a value greater than 255 will result in an overflow error.

Calculating Number of Combinations

● Formula for Combinations: 2^n, where n is the number of bits.

● Example: With 8 bits, there are 2^8 = 256 possible combinations or
distinct numbers (ranging from 0 to 255).

25
Big Idea 2: Data
Roundoff Errors

Explanation of Roundoff Errors: Roundoff errors occur when real numbers are
approximated because their exact decimal representation requires more digits
than the computer can handle. For example, the fraction ⅓ might be
represented differently depending on the precision level of the computer:

● One system might approximate ⅓ as 0.33333.

● Another system might calculate it as 0.33333333333333.

This variation means that ⅓ on one system does not exactly equal ⅓ on
another, leading to discrepancies in calculations and results.

Lossy vs. Lossless Data Compression

Data Compression Overview: Data compression reduces the size (number of

bits) of data that needs to be stored or transmitted, often necessary to manage
large datasets or for efficient transmission.

Lossy Compression:

● Application: Commonly used in scenarios like streaming media, where

exact reproduction of the original data is less critical than reducing file
size.
● Characteristics: Significantly reduces data size by removing some
information, leading to potential loss in quality.
● Example: JPEG image compression, which may reduce image quality but
significantly decreases file size.

Lossless Compression:

● Application: Used where preserving the original data perfectly is crucial,

such as in legal documents or certain scientific data.
● Characteristics: Reduces file size without losing any original data; the
original file can be perfectly reconstructed from the compressed file.
● Example: ZIP file compression, which reduces file size but ensures the
original data can be fully restored.

26
Big Idea 2: Data
Choosing the Right Compression:

● Quality vs. Size: Choose lossy compression when file size reduction is
more important than quality. Opt for lossless compression when
quality or fidelity to the original is critical.
● Use Case Consideration: For everyday use like emails or casual
photography, lossy compression is sufficient. For archival purposes or
where data integrity is paramount, use lossless compression.

Information Extracted from Data

Example of Data Generation and Usage:

● Every day, people generate significant amounts of digital data

through activities such as social media usage. Social media platforms
collect data on user behavior, preferences, and interactions. This data
can be analyzed to tailor content, recommend connections, or target
advertising, demonstrating the practical application and value of
data in commercial contexts.

Processing Information with Computer Programs

● Computer programs are powerful tools for processing information

and gaining insights from vast amounts of data. Information consists
of patterns and facts derived from data, and it is essential in various
fields, including business, science, and technology.

27
Big Idea 2: Data
Combining Disciplines for Insight: Gaining meaningful insights from
data involves a blend of skills:

● Statistics: For analyzing trends and making predictions.

● Mathematics: For creating models and understanding relationships.
● Programming: For manipulating data and automating tasks.
● Problem Solving: For addressing and overcoming challenges
presented by data sets.

Real-World Application: Investors, for instance, analyze historical pricing

data to predict future market trends. This predictive capability is crucial
for making informed investment decisions.

Challenges in Data Processing

Misinterpretation of Trends: While data can reveal trends, these trends

can sometimes be misinterpreted, potentially leading to costly business
mistakes. For example, a correlation in data does not necessarily imply a
causal relationship, and relying on such correlations without deeper
analysis can lead to erroneous conclusions.

Data Uniformity Issues: Data collection methods can vary greatly,

leading to inconsistencies. For instance:

● User Input Variability: If data is entered into an open field, variations

in abbreviation, spelling, or capitalization can occur.
● Data Cleaning: This process involves standardizing data to ensure
uniformity without altering its meaning. For example, harmonizing
different abbreviations or spellings.

28
Big Idea 2: Data
Challenges with Large Data Sets:

● Cleaning Data: Ensuring data is accurate and uniform.

● Incomplete Data: Missing data entries that need addressing.
● Invalid Data: Incorrect data that needs correction.
● Combining Data Sources: Integrating data from different sources to
form a coherent set.

Big Data Issues:

● Processing Capacity: Large datasets may require advanced

processing capabilities or parallel computing systems due to their
size.
● Bias in Data: Data can reflect biases from the sources it was
collected from, and large datasets can amplify these biases.
● Sample Representativeness: Data must accurately represent the
population for the results to be valid and generalizable.

The Role of Algorithms in Modern Life

Predictive Algorithms: Using big data, algorithms can influence daily

decisions and behaviors by identifying and acting on trends. These
algorithms are prevalent in areas such as:

● Social Media: Analyzing user activity to tailor content and

advertisements.
● Retail: Predicting purchasing behavior to optimize inventory and
marketing strategies.

Despite their utility, these algorithms must be used responsibly to avoid

perpetuating existing biases or creating new ones.

29
Big Idea 2: Data
Leveraging Data for Strategic Decisions

Data-driven decision-making is pivotal across various sectors. Here are

some illustrative examples of how businesses and platforms utilize data:

1. Credit Card Companies:

○ Usage: Analyzing purchasing patterns to extend credit or flag
transactions as potential fraud.
○ Impact: Enhances security and trust, while optimizing credit
offerings based on consumer behavior.
2. Social Media Platforms:
○ Usage: Employing user viewing habits to target advertisements
effectively.
○ Impact: Increases ad relevance, enhancing user engagement
and advertiser ROI.
3. Online Retailers:
○ Usage: Suggesting products based on a customer’s past
purchases.
○ Impact: Personalizes the shopping experience, potentially
increasing sales through targeted recommendations.
4. Entertainment Services:
○ Usage: Recommending movies or shows based on viewer’s
preferences.
○ Impact: Enhances user satisfaction and engagement by
curating content that aligns with individual tastes.

30
Big Idea 2: Data
Importance of Data Visualization

Visualization Techniques: Proper visualization of data is crucial for interpreting

complex information efficiently. Effective use of visual tools can turn raw data
into actionable insights. Common visualization types include:

● Column Charts and Bar Charts: Useful for comparing quantities across
categories.
● Line Graphs and XY Charts: Ideal for displaying data trends over time or
relationships between variables.
● Pie Charts: Effective for showing proportional distributions.
● Radar Charts: Helpful in comparing multiple variables.
● Histograms: Used for depicting the distribution of numerical data.
● Waterfall Charts: Good for visualizing sequential changes in data.

Data Privacy and Metadata

Privacy Concerns: With the mass collection of data, privacy becomes a significant
concern. The content of collected data can contain sensitive personal information which
necessitates careful handling, especially in terms of storage and transmission.

Example of Privacy Concern:

● Using an email service like Gmail to order shoes may result in targeted
advertisements for similar products appearing in your search results or social
media feeds.

Understanding Metadata:

● Definition: Metadata describes other data. For instance, for a photograph,

metadata may include the location and time it was taken.
● Usage: Metadata aids in organizing and accessing data, providing context that
enhances the utility of the primary data.
● Stability: Alterations to metadata do not affect the primary data, ensuring that
the integrity of the original data is maintained.

31
 Big Idea 3:
Programming and
Algorithms

Return to Table of Contents

Big Idea 3: Programming and Algorithms
The Concept of Abstraction in Computer Science

Abstraction is a fundamental concept in computer science that involves representing

essential features without including unnecessary details. It simplifies the complexity
of systems, making it easier to design and implement software. Abstractions are
crucial as systems grow more intricate.

Example of Abstraction in Daily Use: When you check stories on Instagram,

numerous processes occur in the background. Abstractions allow you to interact with
the app seamlessly, focusing on the content rather than the underlying technical
operations. This means you can send a message or post a photo without needing to
understand the network protocols, data encryption, or server interactions that make
it all possible.

Programming and Abstractions

Purpose of Abstraction: In programming, abstraction serves to hide the coding

details, allowing programmers to concentrate on solving the current problem
without getting bogged down by the underlying complexities.

Machine Code vs. High-Level Programming Languages:

● Machine Code: The fundamental language understood by computers,

consisting strictly of binary numbers. It is fast but extremely difficult for humans
to write and understand directly.
● High-Level Languages: Languages like Python and Java offer higher levels of
abstraction, making programming more accessible and understandable. These
languages are closer to human language, which simplifies the coding process.

Common Abstractions on the AP Exam

Procedural Abstraction: Procedural abstraction involves grouping code into

procedures or functions, which enhances readability and reusability. It allows
programmers to use these procedures without knowing the details of how they
operate.

Examples of Abstraction Used in AP Computer Science:

1. DISPLAY(expression):
○ This procedural abstraction displays the value of an expression.
2. RANDOM(a, b):
○ This function generates a random number between a and b, inclusive 33
Big Idea 3: Programming and Algorithms
Procedural Abstraction Examples on the AP Exam

1. DISPLAY(expression)

● Explanation: This abstraction is used to display the value of an expression. It abstracts

away the details of output mechanisms, enabling students to focus on what is being
output rather than how it's being displayed.

2. RANDOM(a, b)

● Explanation: This function generates a random number between the integers a and b
(inclusive). It abstracts the complexity of random number generation, providing a
simple interface for getting random values.

Assignment Using Arrows

In some programming languages and pseudocode, the arrow ( ← ) is used to denote

assignment, which assigns the value of an expression to a variable. This differs from the
equality operator (=) used in many high-level languages.

Displaying Boolean Evaluations:

Relational Operators

Relational operators, often called relational operators, are used to compare two values or
expressions. The result of such a comparison is a Boolean value, true or false.

Chart of Common Operators and Their Uses

Explanation: Each operator allows for different types of calculations or comparisons:

● Arithmetic operators (+, -, *, /, MOD) perform mathematical operations.

● Relational operators (=, <, >, <=, >=) compare values, useful in control flow and
decision-making processes.

34
Big Idea 3: Programming and Algorithms
Chart of Common Relational Operators and Their Uses:

Operator Meaning Example

+ Addition 3 + 2 //5

- Subtraction 3 - 2 //1

* Multiplication 3 * 2 //6

/ Division 3 / 2 //1.5

MOD Modulus 3 MOD 2 //1

< Less Than 4 < 5 //true

> Greater Than 5 < 4 //false

<= Less Than or Equal to 4 <= 6 //true

>= Greater Than or Equal 8 >= 9 //false

to

= Equal 4 = 5 //false

35
Big Idea 3: Programming and Algorithms
Modulus Operator Example

Explanation of the Value of a: The modulus operator finds the remainder of

the division of one number by another. In this case, 26 MOD 2 calculates the
remainder when 26 is divided by 2, which is 0, since 26 is evenly divisible by 2.

Tutorial to Calculate Modulus Value

How to Calculate the Modulus:

1. Divide the left number by the right number.

2. The modulus value is the remainder of this division.

Special Cases:

● Example: a ← 3 MOD 4
○ Explanation: If the divisor is larger than the dividend (3 divided by 4),
the remainder is the dividend itself, so a would be 3.
● Dividing by Zero: a ← 6 MOD 0
○ Result: This operation will result in an error as division by zero is
undefined in mathematics and programming. If this was the other
way around, it would be 0.

Order of Operations: PEMDAS

In programming, the order of operations follows the well-known PEMDAS rule:

● Parentheses
● Exponents
● Multiplication and Division (from left to right)
● Addition and Subtraction (from left to right)
● Modulus is treated like division and multiplication in terms of precedence.

36
Big Idea 3: Programming and Algorithms
Variable Assignment and Reassignment Example

Explanation: This example shows how variables can be set and then
changed within a program. Understanding that the latest assignment is
what defines the variable’s value is crucial.

Practice Questions: Basic Arithmetic in Programming

Question 1: Calculate a if a ← (5 + 3) * 2 MOD 3

● Calculation: First, add 5 and 3 to get 8, multiply by 2 to get 16, and

then take 16 % 3 which gives a remainder of 1.
● Answer: a is 1.

Question 2: What is the value of b if b ← 10 - 6 / 3

● Calculation: Division first, 6 / 3 equals 2, then subtraction, 10 - 2

equals 8.
● Answer: b is 8.

37
Big Idea 3: Programming and Algorithms
Understanding Percentage Chance in Programming with Examples

Example 1: Calculating Percentage Chance for a Single Event

Question: What is the percentage chance that a equals 3?

Explanation:

● Total Possible Selections: 1, 2, 3, 4

● Favorable Outcome: The number 3
● Calculation: There is one favorable outcome (3) out of four possible outcomes, so the
chance is 1/4 which converts to 25%.
● Percentage Chance: 25%

This calculation reflects basic probability principles where the likelihood of an event
occurring is the ratio of favorable outcomes to the total number of possible outcomes.

Example 2: Calculating Percentage Chance for Multiple Favorable Outcomes

Question: What is the percentage chance that a is less than or equal to 3?

Explanation:

● Total Possible Selections: 1 through 10

● Favorable Outcomes: 1, 2, 3
● Calculation: There are three favorable outcomes (1, 2, 3) out of ten possible outcomes,
so the chance is 3/10.
● Percentage Chance: 30%

In this case, because there are three numbers (1, 2, and 3) that satisfy the condition a <= 3 out
of ten possible numbers, the probability is 30%. This example teaches how to account for
multiple favorable outcomes when calculating the likelihood of an event.

38
Big Idea 3: Programming and Algorithms
Concept of Data Abstraction

Data abstraction is a fundamental concept in computer science that involves

separating the abstract properties of a data type from the concrete details of its
implementation. This separation simplifies complex systems by enabling
programmers to work with data collections under a unified interface without
needing to know the specifics of their storage or representation.

Lists as Data Abstractions

Definition and Usage: Lists (also known as arrays in some programming

languages) allow multiple related items to be grouped together and treated as
a single entity. This grouping simplifies operations that involve multiple data
points, such as calculations, sorting, and searching.

Lists enhance readability and manageability of code by reducing the need for
multiple individual variables and allowing complex data manipulations
through built-in methods and functions.

Why are Lists important?

Using a list simplifies these operations by providing a flexible and efficient way
to store, access, and manipulate data. Lists enable easier implementation of
functions and operations over the data set, significantly reducing the
complexity and enhancing the maintainability of the program.

39
Big Idea 3: Programming and Algorithms
Basic Concepts of Lists

Lists are structured collections that store data in an organized manner,

allowing for efficient data retrieval and manipulation. Each element in a
list is assigned a unique index, which can be used to access the element
directly.

Indexing in Lists:

● In many programming languages like Python and JavaScript,

indexing starts at 0. However, on the AP Computer Science Principles
exam, lists are indexed starting at 1.
● Accessing an element by its index is straightforward: listName[index]
retrieves the element at that specific position.

scores ← [11, 35, 6, 75, 37]

Scores[1] //11
scores[2] //35

In this example, scores[1] accesses the first element of the list, which is 11,
adhering to the AP exam's indexing rule.

Handling Index Out of Bounds Errors

When you try to access an index that is less than 1 or greater than the
length of the list, it results in an "index out of bounds" error. On the AP
exam, attempting to access a non-existent index will terminate the
program, unlike some programming languages that might return
undefined or throw an exception without terminating the program.

40
Big Idea 3: Programming and Algorithms
Inserting Elements into a List

The INSERT(list, i, item) function is used to insert an item into the list at a
specified index i. This function modifies the list by placing the new item at
the index i and shifting elements at index i and higher to the right.

Explanation of What This Does:

● Before Insertion: The list words contains ["Hey", "How", "Are", "You"]
● After Insertion: The item "Green" is inserted at the third position:
○ New list after insertion: ["Hey", "How", "Green", "Are", "You"]

The element "Green" is added to the list at index 3, while "Are" (previously
at index 3) and "You" (previously at index 4) are shifted right to indices 4
and 5, respectively.

41
Big Idea 3: Programming and Algorithms
List Operations in Programming: Append, Insert, and Remove

Demonstrating List Operations with Examples

Given an initial setup and a series of operations, let's walk through how
these modify a list. The operations we will explore are APPEND, INSERT,
and REMOVE.

Using REMOVE

42
Big Idea 3: Programming and Algorithms
Explanation of What Happened:

Initial List Operations:

● The INSERT operations place new elements at specified positions

within the list, pushing existing elements to the right.
● The APPEND operations add new elements to the end of the list,
extending the list's size.

Removal Operations:

● The REMOVE function deletes an element at a specified index. The

first REMOVE operation deletes "Elephant" from the list, and
subsequent elements shift left to fill the gap.
● The second REMOVE operation, adjusted after the list has been
altered by the first removal, deletes "Fox." Again, the remaining
elements shift left, compacting the list further.

43
Big Idea 3: Programming and Algorithms
Understanding Conditionals in Programming

What are Conditionals?

Conditionals are fundamental constructs in programming that allow you to

make decisions in your code based on whether certain conditions are true or
false. They are used to execute different blocks of code based on different
inputs or states of the program.

Structure of Conditionals

The basic structure of a conditional in most programming languages, including

JavaScript, involves an if statement possibly followed by an else statement:

IF condition
{
LOG("Condition met")
} ELSE
{
LOG("Condition not met")
}

Relational Operators Used in Conditions

Relational operators, more commonly referred to as relational operators, are

used within conditions to compare expressions. These include:

● == or ===: Equality and strict equality

● != or !==: Inequality and strict inequality
● <: Less than
● >: Greater than
● <=: Less than or equal to
● >=: Greater than or equal to

These operators evaluate the relationship between two values or expressions

and return a Boolean value (true or false), which determines which block of
code the conditional executes.

44
Big Idea 3: Programming and Algorithms
Examples of Conditional Statements

Example 1: Simple If-Else Statement

Explanation: The condition checks if the score is 70 or higher. If true, it

prints "You passed!" If false, it prints "You need to try again."

Example 2: Using the Logical OR Operator ( || )

The logical OR operator (||) is used in conditions to check if at least one of

multiple conditions is true. It returns true if either of the conditions
evaluates to true.

Note: You might see || instead of “or” on the AP Exam.

45
Big Idea 3: Programming and Algorithms
Example 3: Using the Logical AND Operator

The logical AND operator (&&) is used in conditions to check if all of the
given conditions are true. It returns true only if all conditions evaluate to
true.

Explanation: This example checks if the individual is 18 years or older and

if they have permission (perhaps from a parent or guardian). Both
conditions must be true for the individual to be allowed to enter the club.
If either condition is false, the individual will not be allowed entry.

Note: You might see && instead of “and” on the AP Exam especially if its in
text.

46
Big Idea 3: Programming and Algorithms
Loops are fundamental constructs in programming that allow repetitive tasks
to be executed efficiently. Let's explore two common types of loops: the
"Repeat n Times" loop and the "Repeat Until Condition" loop.

Loop 1: REPEAT n TIMES

This loop type executes a block of statements a specified number of times. This
is a straightforward way to perform a task multiple times without manually
writing the code repeatedly.

Explanation:

● Operation: The loop will execute the block of statements DISPLAY("Hello,

world!") five times.
● Behavior: Each iteration prints "Hello, world!" to the screen, resulting in
the message being displayed five times.

Loop 2: REPEAT UNTIL(Condition)

This loop continues to execute as long as a condition is false and stops once
the condition becomes true. This is somewhat opposite to a typical while loop
seen in languages like Python, which continues as long as the condition is true.

Explanation:

● Operation: The loop starts with counter set to 1 and repeats the block of
statements until counter exceeds 5.
● Behavior: Inside the loop, it displays the current value of counter and then
increments counter by 1. The loop stops when counter becomes 6, having
printed values from 1 to 5.
47
Big Idea 3: Programming and Algorithms
Key Points to Remember:

● Relational Operators: These are used in the condition to compare

expressions (e.g., counter > 5). These operators help determine
whether the loop should continue or terminate.
● Loop Purpose: This type of loop is particularly useful when you need
to perform actions until a certain condition is met, such as waiting for
user input to reach a particular state or processing items until a
condition changes.

Practical Application of Loops

Loops are essential for managing repetitive tasks without unnecessary

code duplication, enhancing the readability and maintainability of
programs. Understanding how to effectively use different types of loops
based on the scenario (e.g., knowing when to use a fixed number of
iterations vs. waiting for a condition to change) is crucial for efficient
programming.

48
Big Idea 3: Programming and Algorithms
Loop 3: Looping Through a List

Looping through a list or an array allows you to perform operations on each element in the
collection sequentially. This type of loop, often referred to as a "FOR EACH" loop, is incredibly
useful for handling collections of items without manually indexing each element.

Explanation of FOR EACH Loop

In a FOR EACH loop, a temporary variable is assigned to each element in the list, one at a
time, from the first to the last. The block of statements within the loop then operates on
each of these elements.

This structure simplifies operations on arrays or lists by abstracting the process of iterating
over each element, thereby avoiding manual loop controls and index management.

Example: Logging Each Item in an Array

Let's take a practical look at how this works with an example.

● Setup: The text array contains several words.

● Loop Operation: FOR EACH method is used here to iterate over each element in the
text array.
● Function Execution: For each element, the DISPLAY function is called with item as
the argument, which prints each word to the console.

How It Works:

● Iteration: Each element in the array text is passed in turn to the function defined
inside the forEach. The function then executes, logging each item.
● Flexibility: This method is useful for any operation that needs to be applied to each
element of an array, such as transforming data, filtering, or aggregating information.
49
Big Idea 3: Programming and Algorithms
Practical Use and Efficiency

Using a FOR EACH loop is especially advantageous when you need to ensure
that every element of a list or array is accessed and processed, as it
automatically handles the traversal of the collection. This eliminates potential
errors from manual index handling and makes the code cleaner and easier to
read.

FOR EACH loops are particularly well-suited for collections where the operation
does not need to modify the list's structure (i.e., not adding or removing
elements during iteration), as it purely focuses on accessing each element.

Loop 4: Looping Through a List with a Counter-Controlled Loop

In this version of looping through a list, you use a counter to control the
number of iterations based on the length of the list. This approach is a
traditional method used in many programming languages, especially when
specific indexing is necessary or when manipulating the index directly is part of
the logic.

Explanation of the Given Code

The provided pseudo code demonstrates how to calculate the sum of all
numbers in a list by iterating through each element using a counter-controlled
loop:

50
Big Idea 3: Programming and Algorithms
Step-by-Step Breakdown:

1. Initialization:
○ sum is initialized to 0. This variable will accumulate the total of
all numbers in the list.
○ n is set to the length of the list, determining how many times
the loop will execute.
○ index starts at 1, assuming list indexing begins at 1 (as per AP
Computer Science Principles guidelines).
2. Loop Execution:
○ The loop is set to REPEAT n TIMES, equal to the number of
elements in the list.
○ Inside the loop:
■ The current item in the list list[index] is added to sum.
■ index is then incremented by 1 to move to the next item in
the list on the subsequent iteration.
3. Display the Result:
○ After the loop completes (having iterated through each element
of the list), the total sum is displayed using DISPLAY(sum).

51
Big Idea 3: Programming and Algorithms
Explanation of What’s Happening:

This loop methodically adds each number in the list to sum. By

incrementing index each time, every element from the first to the last is
accessed and added together. The final value of sum after the loop
concludes is the total of all elements in the list.

Tips for Managing Complexity in Loops:

● Use Pencil and Paper: As you suggested, using pencil and paper to
track the values through each iteration can be incredibly helpful.
Write down the current value of sum and index at each step to
visualize the process and ensure accuracy.

52
Big Idea 3: Programming and Algorithms
What is a Procedure?

A procedure, also known as a method or subroutine in some

programming languages, is a named block of code that performs a
specific task. It can be called multiple times throughout a program by
invoking its name, which makes the code cleaner, more modular, and
easier to manage.

Why Use Procedures?

Procedures are used to avoid repetition of the same code lines across a
program. By encapsulating a sequence of instructions into a single,
reusable procedure, you can:

● Reduce Code Duplication: Streamline your codebase by writing the

logic once and using it throughout the program wherever needed.
● Simplify Maintenance: Changes to a procedure affect all parts of a
program that use it, making updates easier and less error-prone.
● Enhance Readability: Clear, well-named procedures make it easier
for someone new to the code to understand what it does.

53
Big Idea 3: Programming and Algorithms
Example of Procedure

Let's create two procedures as examples: one that doubles each value in a
list, and another that adds all the numbers in a list.

Explanation:

● Procedure Name: doubling

● Parameter: list (an array of numbers)
● Functionality: The procedure iterates over each element of the array,
doubling its value.
● Return Value: The modified list with each value doubled.

54
Big Idea 3: Programming and Algorithms
⭐ Common Algorithms on AP Exam ⭐ (Page 57 - 67)

Algorithm Description: Find Total Sum of a List

The purpose of this algorithm is to compute the total sum of all elements
in a list. This operation is frequently used in data analysis, financial
calculations, and anywhere you need to aggregate numerical data.

Breakdown of the Algorithm

1. Initialization:
○ sum ← 0: We start by initializing sum to 0. This variable will hold
the cumulative total of the numbers as we iterate through the
list.
2. Loop Through Each Element:
○ FOR EACH item IN scores: This loop iterates over each element
in the list scores. The variable item takes on the value of each
element in the list one by one.
3. Accumulate the Sum:
○ sum ← sum + item: Inside the loop, we add the current element
(item) to the running total (sum). Each iteration updates sum to
include the value of the current item.
4. Return the Total:
○ RETURN sum: After the loop has processed all elements in the
list, the procedure returns the total sum accumulated. 55
Big Idea 3: Programming and Algorithms
Understanding What’s Happening

● Loop Mechanics: The FOR EACH loop is straightforward and

efficient for accessing each element in the list without manually
handling the index. It ensures that every item in the list is
considered.
● Accumulation Process: Each step of the loop adds the current
item’s value to sum, effectively accumulating the total of all
items in the list.
● Final Output: The final value of sum after all iterations is the sum
total of all the elements in the list scores.

56
Big Idea 3: Programming and Algorithms
Understanding the Algorithm: Finding the Average of a List

Calculating the average of a list of numbers is a fundamental task in programming,

used in countless applications to summarize and analyze datasets. Let's break down
two versions of this algorithm written in pseudocode.

Implementation 1: Using FOR EACH Loop

Step-by-Step Explanation:

1. Initialization of sum:
○ sum ← 0: Start with a sum of zero to which the values from the list will be
added.
2. Iterating Through the List:
○ FOR EACH item IN list: This loop goes through each item in the list one by
one.
○ sum ← sum + item: In each iteration, the current item's value is added to
sum.
3. Calculating the Average:
○ RETURN(sum / LENGTH(list)): After all items are added to sum, the
average is calculated by dividing sum by the number of items in the list
LENGTH(list). The RETURN statement outputs the result of this division,
which is the average.

57
Big Idea 3: Programming and Algorithms
Implementation 2: Using REPEAT n TIMES Loop

Step-by-Step Explanation:

1. Initialization:
○ sum ← 0: Initializes the sum to zero.
○ n ← LENGTH(list): Stores the number of items in the list in n.
○ index ← 1: Starts the index at 1, considering the AP exam's 1-based
indexing.
2. Looping Through the List:
○ REPEAT n TIMES: The loop is set to iterate n times, which is the
length of the list.
○ Inside the loop:
■ sum ← sum + list[index]: Adds the value at the current index of
the list to sum.
■ index ← index + 1: Increments the index to move to the next
item in the list.
3. Returning the Average:
○ RETURN sum/n: After all iterations, the loop has summed all
elements in the list. Dividing this sum by n (the total number of
items) gives the average. This value is then returned.
58
Big Idea 3: Programming and Algorithms
Understanding Both Implementations

● Key Difference: The first implementation uses a FOR EACH loop,

which directly iterates over each element in the list, abstracting away
the need for index management. The second implementation uses a
REPEAT n TIMES loop, explicitly managing the index and ensuring it
increments with each iteration.
● Conceptual Focus: Both methods aim to simplify calculating the
average by first summing all elements and then dividing by the
number of elements. However, the REPEAT n TIMES loop offers more
control, particularly useful in scenarios where index-based operations
are necessary beyond simple summation.

59
Big Idea 3: Programming and Algorithms
Understanding the Algorithm: Finding the Maximum of a List

Finding the maximum value in a list is a common task that involves comparing each
element of the list to determine the largest one. Here, we'll break down two
implementations of a procedure to find the maximum value in a list.

Finding the Maximum of a List (Implementation #1)

Step-by-Step Explanation:

1. Initialize Maximum:
○ max ← list[1]: Start by assuming that the first item in the list is the maximum.
This sets a baseline for comparison.
2. Iterate Through the List:
○ FOR EACH item IN list: Loop through each element in the list.
○ IF(item > max): Check if the current item is greater than the current maximum
(max).
○ max <- item: If the current item is greater, update max to this new value.
3. Return the Maximum:
○ RETURN(max): After finishing the loop, return the value of max, which now
holds the maximum value found in the list.

Rationale Behind Implementation #1:

● The use of a FOR EACH loop simplifies the process of iterating over each element and
focuses on the logic of comparing and updating the maximum value.
● This implementation is straightforward and very readable, making it easy to
understand the logic of finding the maximum value. 60
Big Idea 3: Programming and Algorithms
Finding the Maximum of a List (Implementation #2)

Step-by-Step Explanation:

1. Initialize Variables:
○ max ← list[1]: Initialize max as the first element in the list.
○ n ← LENGTH(list): Determine the number of elements in the list and store it in n.
○ count ← 1: Start a counter at 1 to use for indexing through the list.
2. Loop Through the List Using a Counter:
○ REPEAT n TIMES: Use a repeat loop to go through the list n times, once for each
element.
○ IF(list[count] > max): Inside the loop, check if the current element list[count] is greater
than the current maximum.
○ max ← list[count]: If true, update max to this new larger value.
○ count ← count + 1: Increment count to move to the next element in the list.
3. Return the Maximum Value:
○ RETURN(max): After completing the loop, max will hold the highest value found, which
is then returned.

Rationale Behind Implementation #2:

● This method explicitly manages the indexing of elements, making it clear how each element is
accessed.
● The REPEAT n TIMES structure allows precise control over how many iterations occur,
matching the exact length of the list.
● Manually handling the index with count gives flexibility if modifications to the looping
mechanism are needed, such as skipping elements or other conditions based on the index. 61
Big Idea 3: Programming and Algorithms
Analysis of a Common Error in Finding the Maximum Value

The provided pseudo code contains a typical error that can easily lead to incorrect results,
especially when working with specific types of data such as all-negative lists. Let's break
down the error and understand why it happens.

Issue with the Code:

The error in this code lies in the initialization of the max variable to 0. This approach assumes
that the maximum value in any list will be at least 0, which is not always the case, particularly
with lists containing all negative numbers.

Step-by-Step Breakdown with the Given List [-1, -1, -35, -6]:

1. Initialization:
○ max is initialized to 0. This is intended to provide a starting point for comparison.
2. Loop Through Each Item in the List:
○ The loop iterates over each element in the list: -1, -1, -35, -6.
○ The conditional IF(item > max) checks if the current item is greater than max.
3. Condition Evaluation:
○ For each item in the list [-1, -1, -35, -6], the condition item > max is evaluated
against max = 0.
○ None of these items is greater than 0, so the condition never evaluates to true.
○ Consequently, max remains unchanged at 0.
4. Return Value:
○ The function returns max, which remains 0, not reflecting any of the actual
values in the list.
62
Big Idea 3: Programming and Algorithms
The Logical Error (previous example continued):

The logical error is setting max to 0 at the start. For lists that contain only negative numbers, no
element will ever be greater than 0, so max remains incorrectly set to 0. The algorithm fails to
accurately assess the maximum in cases where all elements are below the initialized value of max.

Analyzing a Common Error in Finding the Minimum Value

The pseudocode provided for the procedure to find the minimum value in a list contains a significant
logical error that results in an incorrect outcome. Let's dissect the error and explain why it occurs.

Issue with the Code:

The fundamental error in this code is in the ELSE branch of the conditional statement, which sets
min to 0 whenever the current item is not less than the current minimum. This logic is flawed and
will generally result in the minimum being incorrectly set to 0 unless the list exclusively contains
negative numbers.

Step-by-Step Breakdown with the List [1, 1, 35, 6]:

1. Initialization:
○ min is initialized to the first element of the list, which is 1. This is a good start as it
represents a real value from the list.
2. Loop Through Each Item:
○ The loop iterates over each element in the list.
3. Condition Evaluation and Update:
○ First Iteration (item ← 1): Since 1 is not less than min (which is 1), the ELSE block
executes, setting min to 0.
○ Subsequent Iterations (items ← 1, 35, 6): For each of these items, since none of them
are less than 0 (the newly set value of min), min remains 0.
4. Return Value:
○ The function returns min, which is now 0, clearly not the minimum value of the original
list.
63
Big Idea 3: Programming and Algorithms
Explanation of What's Happening:

● The initialization and the loop's condition are correctly implemented;

min is initially set to the first item, and the list is correctly iterated to
find the minimum.
● The logical flaw is the reset of min to 0 in the ELSE clause. This reset
is based on an incorrect assumption and should not be part of
finding the minimum value.

Corrected Approach:

The correct implementation should only update min when a smaller item
is found and do nothing otherwise. The corrected pseudocode would look
like this:

Corrected Code Explanation:

● Eliminating the ELSE Clause: By removing the ELSE block, min only
updates when a truly smaller value is found. If no smaller value is
found, min remains correctly at the smallest value encountered.

64
Big Idea 3: Programming and Algorithms
Analyzing the Procedure to Find a Word in a List of Words

The provided pseudocode describes a procedure for finding the index of a specific word within a list.
This is a fundamental search operation in computer science, often used to determine whether and
where a particular element exists within a collection.

Step-by-Step Breakdown:

1. Initialization:
○ index ← 1: Initializes the index to 1, assuming a list indexing starts at 1, which is typical for
the AP exam format.
2. Iterate Through the List:
○ FOR EACH item IN list: Iterates through each item in the list sequentially.
3. Check Each Item:
○ IF(item = word): Checks if the current item matches the word we are searching for.
■ If true, RETURN index: Immediately returns the current index, indicating where
the word was found in the list.
○ ELSE:
■ index ← index + 1: Increments the index by one. This step is necessary to move to
the next item's index in the list.
4. Word Not Found:
○ After the loop completes and if the word has not been found, RETURN “word not in the
list”: This statement is executed if the word is not found in any iteration of the loop.

65
Big Idea 3: Programming and Algorithms
Understanding How to Swap Items in Arrays

Swapping items in an array is a common operation in programming that involves

exchanging the positions of two elements. This process is crucial in various
algorithms, especially in sorting and rearranging data.

Step-by-Step Explanation of Swapping

To simplify the concept of swapping items in an array, think of it like trading seats in a
classroom:

1. Create a Temporary Variable:

○ Imagine you have a placeholder (a temporary seat or a placeholder card)
where you can temporarily keep something. In the case of swapping, you
use a temporary variable to safely store the value of one of the items you're
going to swap.
2. Replace the First Item with the Third Item:
○ Say you initially sit in the first seat (position 1) and want to move to the
third seat (position 3). Before moving, you take whatever is currently in the
third seat and put it in the first seat.
3. Replace the Third Item with the Item Stored in the Temporary Variable:
○ Finally, move the item (or person) that was originally in the first seat (and
now is in your temporary holding area) into the third seat.

Analogy:

Think of it as swapping lunch boxes between two friends. You don't want to mix up
the contents, so you use an extra lunch box (the temporary variable) to hold the
contents of one friend's lunch box while you swap them.

66
Big Idea 3: Programming and Algorithms
Understanding Robot Movement and Rotation Commands

To help students grasp the concept of robot movement and orientation, we can illustrate
these actions using simple tables. These commands are commonly used in programming
exercises, particularly in contexts like robotics and simulations, where directional control and
movement are key aspects.

MOVE_FORWARD() Command and Conditional Movement

The MOVE_FORWARD() command moves the robot forward in the direction it is currently
facing. To prevent the robot from moving into an obstacle or off the map, we use conditional
checks.

67
Big Idea 3: Programming and Algorithms
Explanation:

● REPEAT UNTIL Loop: This loop continues to execute the

MOVE_FORWARD() command as long as the condition
CAN_MOVE(forward) = true holds. Once CAN_MOVE(forward)
returns false (indicating an obstacle or boundary ahead), the loop
exits, and the robot stops moving.

Reaching a Goal

In scenarios where the robot needs to reach a specific target or goal:

Explanation:

● Loop Execution: The loop executes repeatedly until the

Goal_Reached condition becomes true. Inside the loop, you would
include logic to move and rotate the robot as required to navigate
towards the goal.
● Goal Condition: The Goal_Reached condition is checked continually.
Once the robot arrives at the target location, the loop terminates,
and the program can proceed to other tasks or end.
68
Big Idea 3: Programming and Algorithms
Understanding and Tracking Robot Movement on a Grid

When working with robot simulation tasks, such as on the AP

Computer Science Principles exam, you might be required to predict
possible landing spots after a series of movements and rotations. This
can be tricky, but with a systematic approach and visualization tools
like a pencil and paper, it becomes manageable. Let's explore how to
tackle this using the provided pseudocode scenario.

Breaking Down the Scenario

This scenario involves two separate randomized actions: rotating left

a certain number of times and then moving forward a certain
number of times. The randomness adds complexity because it
introduces multiple possible outcomes for each action.

(Next page)

69
Big Idea 3: Programming and Algorithms
Step-by-Step Approach to Determine Possible Landing Spots

1. Understanding the Commands:

● ROTATE_LEFT(): Each call to this function rotates the robot 90 degrees

counterclockwise.
● MOVE_FORWARD(): Moves the robot one tile forward in whatever
direction it is currently facing.

2. Analyzing the Range of Actions:

● First REPEAT Loop: The robot could rotate 0, 1, or 2 times to the left. Each
rotation changes the robot's facing direction:
○ 0 times: Faces original direction.
○ 1 time: Faces 90 degrees counterclockwise from the original.
○ 2 times: Faces 180 degrees from the original.
● Second REPEAT Loop: The robot moves 0, 1, or 2 tiles forward in the
direction it faces after the rotations.

3. Using a Pencil Method to Track Movement:

● Draw a Grid: Start with a 5x5 grid, and mark the robot's starting position
at the center (column 3, row 3).
● Mark Rotations: For each possible rotation scenario (0, 1, 2 times), use an
arrow to indicate the new facing direction from the center.
● Simulate Moves: For each facing direction, draw lines corresponding to
moving forward 0, 1, or 2 tiles. Mark the end of each line. These are
potential landing spots.

4. Testing Each Option:

● Eliminate Impossible Moves: If a move would take the robot off the grid,
mark it as invalid.
● Count Valid Landing Spots: Note all the grid squares where the robot
could potentially stop.

By physically drawing these paths on paper, you can visually track where the
robot might end up based on different sequences of actions.
70
Big Idea 3: Programming and Algorithms
Analyzing Robot Movement on a Grid with Random Actions

In this scenario, a robot on a 5x5 grid performs a series of random rotations and
movements. The randomness in both rotations and movements introduces
multiple possible outcomes, making it essential to systematically analyze the
potential results. Here’s a step-by-step guide on how to figure out the robot's
possible landing spots based on the given pseudocode.

(Step by step solution on next page)

71
Big Idea 3: Programming and Algorithms
Step 1: Analyze the Rotation Command

● Command: ROTATE_LEFT()
● Randomness: The robot will rotate left between 1 and 3 times. Each ROTATE_LEFT() rotates
the robot 90 degrees counterclockwise.

Possible Rotations:

● 1 rotation: The robot ends up facing West if it started facing North.

● 2 rotations: The robot ends up facing South if it started facing North.
● 3 rotations: The robot ends up facing East if it started facing North.

Step 2: Analyze the Movement Command

● Command: MOVE_FORWARD()
● Randomness: The robot will move forward between 1 and 2 steps in whatever direction it is
currently facing after the rotations.

Mapping Out the Movements on a 5x5 Grid:

1. Draw the Grid: Sketch a 5x5 grid and mark the starting position in the middle (position C3, if
using column-row notation).
2. Mark Possible Rotations: From the center position, draw arrows in the directions the robot
could potentially face after its rotations (West, South, East).
3. Simulate the Movements:
○ If facing West:
■ Move 1 step west to B3.
■ Move 2 steps west to A3 (if it doesn't exceed grid boundaries).
○ If facing South:
■ Move 1 step south to C2.
■ Move 2 steps south to C1.
○ If facing East:
■ Move 1 step east to D3.
■ Move 2 steps east to E3 (ensure it stays within the grid).

Step 3: Visualize and Mark Possible Endings

● For each direction the robot could face, use different colored pencils or markers to plot the
1-step and 2-step moves. This helps to visually differentiate the possible ending spots based on
the number of steps taken.

Step 4: Evaluate and Consider Edge Cases

● Boundary Checks: Ensure that none of the movements take the robot off the grid. If a move
would exceed the grid limit, it should not be considered a valid ending spot.
● Overlap Areas: There may be scenarios where different paths lead to the same grid cell. Mark
these overlaps distinctly as they represent higher probability landing spots.
72
Big Idea 3: Programming and Algorithms
Understanding Linear Search

Linear search, also known as sequential search, is a fundamental search algorithm used
in computing to find a specific element within a list. It works on both sorted and
unsorted lists, making it one of the most straightforward searching techniques. Let's
break down the process and how to calculate the number of comparisons needed to find
an element.

How Linear Search Works

Linear search begins at the first element of the list and sequentially checks each
subsequent element until the desired element is found or the list ends. This method is
simple and does not require the list to be sorted, unlike more complex algorithms like
binary search.

Key Points:

● Best Case Scenario: The best case occurs when the target element is the first item
in the list. Here, only one comparison is needed.
● Worst Case Scenario: The worst case happens when the target is at the end of the
list or not present at all. In such cases, the number of comparisons equals the
number of elements in the list (n).

Examples of Linear Search

Example 1: Finding the Number '11' in a List

numList ← [“11”, “35”, “2”, “1”, “56”, “76”, “3”, “33”, “90”, “180”]

To find the number “11”:

● Start at the beginning of the list.

● Compare the first element with “11”'.
● Since the first element is “11”, the search is successful with just one comparison.

Example 2: Finding the Number ”180” in a List

To find the number “180”:

● Start at the beginning of the list.

● Sequentially compare each element with “180” until you reach the end of the list.
● ”180” is the last element in this list, so it would take 10 comparisons to find “180”

73
Big Idea 3: Programming and Algorithms
Calculating the Number of Comparisons Using Index

If you know the position (index) of an element in the list, you can directly
determine the number of comparisons needed in a linear search:

numList ← [“11”, “35”, “2”, “1”, “56”, “76”, “3”, “33”, “90”, “180”]

● Index Method: The number of comparisons needed to find an element is

equal to its index in the list
● Example Using Index:
● For “56” in numList, if we know “56” is at index 5:
○ numList[5] = 56
○ It takes 5 comparisons to find “56” using a linear search.

Understanding Binary Search

Binary search is an efficient algorithm for finding an element in a sorted list by repeatedly
dividing the search interval in half. It is significantly faster than linear search, especially for
large lists, because it reduces the search space exponentially at each step.

Why Binary Search Requires a Sorted List

Binary search operates under the assumption that the list is sorted in increasing order. This
sorting allows the algorithm to decisively eliminate half of the search space after each
comparison, based on whether the target value is greater or lesser than the middle element.

The Logic Behind Binary Search

Here’s the intuitive logic for why binary search works effectively:

● Initial Middle Comparison: Start by comparing the target value with the middle
element of the list.
● Decision Process:
○ If the target value is equal to the middle element, the search is successful.
○ If the target value is less than the middle element, then it must be in the left half
of the list (because the list is sorted in increasing order).
○ If the target value is greater than the middle element, then it must be in the
right half.
● Repeat Process: This process of halving the list is repeated on the new half (either left
or right), continually narrowing down the possible locations of the target until it is
found or the search space is exhausted.

74
Big Idea 3: Programming and Algorithms
Example of a Binary Search in Steps

Let's go through a step-by-step example of binary search on a sorted

array:

sortedarray ← [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]

Target to Find: 23

1. Initial Middle: The middle element of [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
is 16 (at index 4).
2. Comparison: 23 is greater than 16, so we eliminate the left half of the
array including 16.
3. New Search Space: [23, 38, 56, 72, 91]
4. New Middle: The middle of [23, 38, 56, 72, 91] is 56 (at index 2 of the
new subarray).
5. Comparison: 23 is less than 56, so we eliminate the right half of the
array including 56.
6. New Search Space: [23, 38]
7. New Middle: The middle of [23, 38] is 23.
8. Comparison: 23 equals 23, so the search is successful.

Comparison with an Unsorted Array

unsortedarray ← [5, 12, 2, 16, 23, 8, 56, 38, 72, 91]

If you attempted binary search on this unsorted array, the logic of halving
based on greater or lesser comparisons breaks down. For example, finding
23 in this unsorted array via binary search would lead to incorrect
eliminations and potentially not finding the target at all.

75
Big Idea 3: Programming and Algorithms
Understanding Flowcharts in Program Design

Flowcharts are essential tools in programming for visualizing the flow of logic in
algorithms and processes. They use various standardized symbols to represent different
types of actions or steps in a program. Let’s define these symbols and how they're used in
a flowchart, and then look at an example flowchart with its corresponding trace.

Flowchart Symbols and Their Meanings

Here's a chart explaining the common symbols used in flowcharts:

Tips for Tracing Flowcharts to Determine Outputs:

1. Follow the Path: Start at the 'Start' symbol and follow the paths according to the
input and decisions made at each diamond shape.
2. Understand Decisions: Pay close attention to the decision symbols (diamonds).
Ensure you understand the condition being tested.
3. Look for Loops: If the flowchart contains loops, make sure to understand how
many times the loop runs and under what conditions it stops.
4. Check for Multiple Endpoints: Some flowcharts may have multiple end points
depending on decisions made; ensure to trace each possibility based on different
inputs.
5. Use Scratch Paper: Write down or sketch the path you're following along with any
variables' values to keep track of the process and outcomes.
76
Big Idea 3: Programming and Algorithms

77
Big Idea 3: Programming and Algorithms
Algorithmic Efficiency: Some problems do not have efficient algorithms capable
of solving them within a reasonable timeframe. For these problems, algorithms
with polynomial efficiency (constant, linear, square, cube, etc.) are typically
considered efficient as they can be executed quickly on modern processors.
However, many important and practical problems lack known polynomial-time
algorithms and are tackled using algorithms with exponential or factorial
efficiencies, which are generally too slow to be practical for large datasets.

Heuristic Approaches: A heuristic is a practical approach to solving problems

where an optimal solution is impractical. Heuristics provide solutions that are
good enough under the given circumstances. For example, a file-organizing
algorithm that categorizes files based on a limited number of initial bytes offers a
faster, though less comprehensive, solution than one which examines every byte.

Decomposition and Abstraction in Programming: Programmers often break

down complex problems into smaller, more manageable components. By
creating reusable procedures and leveraging parameters, they can abstract away
the complexities of specific tasks. This abstraction allows programmers to rely on
previously tested code, thereby speeding up development and enhancing
confidence in their solutions.

Leveraging Software Libraries: Software libraries contain pre-written procedures

that can be utilized in new programs. Examples include Python’s 'random' and
'numpy' libraries. These libraries simplify the task of developing complex programs
by providing robust, pre-tested modules that implement common tasks.

Application Programming Interfaces (APIs): APIs specify how the components

of a library can be used in programming. For instance, Twitter's API allows
developers to access and manipulate tweet data. Proper documentation of these
APIs is crucial as it guides programmers on how to effectively use the provided
functionalities.

Computational Devices: A variety of computing devices are capable of running

these programs, including computers, tablets, servers, routers, and smart sensors.
These devices must be capable of taking inputs, processing data, and calculating
results based on those inputs.

78
 Big Idea 4:
Computer Systems
and Network

Return to Table of Contents

Big Idea 4: Computer Systems and Network
Understanding Computing Devices, Systems, and Networks

Computing Devices: A computing device is a physical artifact capable of

running a program. Examples of these devices include computers, tablets,
servers, routers, and smart sensors. These devices are designed to receive
inputs, process these inputs, and produce outputs based on the processed
data.

Computing Systems: A computing system refers to a collection of computing

devices and programs that work collaboratively to achieve a specific objective.
This collaboration enhances the capabilities beyond what a single device could
achieve independently.

Computer Networks: A computer network is an ensemble of interconnected

computing devices that can send and receive data. Networks allow multiple
devices to communicate and share resources efficiently. The bandwidth of a
network refers to the maximum rate at which data can be transferred across
the network in a given period of time.

Networking Concepts:

Path and Routing:

● Path: In networking, a path is defined as a sequence of directly connected

devices that begins with a sender and ends with a receiver.
● Routing: This is the process of finding a viable path from a sender to a
receiver within a network. If a disruption occurs along the path, routing
algorithms find an alternative path, showcasing the fault-tolerant nature
of internet connections.

Internet Infrastructure:

Components and Connectivity:

● The internet is a vast physical network composed of fiber optic cables,

radio transmitters, and various forms of cabling. This infrastructure
supports the global connectivity of devices and networks.

80
Big Idea 4: Computer Systems and Network
Protocols and Internet Functionality:

● Protocol: A set of agreed-upon rules that dictate how data is transmitted across a
network. Protocols ensure reliable and standardized communication between devices.
● Internet Protocol (IP): IP is crucial for addressing and routing. It assigns unique
addresses (IP addresses) to each device on the internet, facilitating precise data
routing.

Scalability and Evolution of Internet Protocols:

● Scalability: This refers to the ability of a network or system to expand and adapt to
increased demands. The internet's design allows it to scale up efficiently,
accommodating more devices and data traffic without losing performance.
● Evolution of Protocols: Internet protocols have evolved to support the growing scale
and complexity of global networks. This evolution is necessary to handle the increasing
number of devices and the vast amount of data transmitted over the internet.

Transition from IPv4 to IPv6 and Networking Protocols

As technology advances and the number of devices connected to the internet increases, the
protocols and infrastructure that support network communication must evolve. Here's an
overview of the transition from IPv4 to IPv6, the roles of TCP and UDP, and the concepts of
fault tolerance and redundancy in network systems.

IPv4 vs. IPv6

IPv4 (Internet Protocol version 4):

● Address Length: Uses 32 bits for IP addresses, allowing for approximately 4.29 billion
unique addresses (2^32).
● Limitation: The explosive growth of the internet and connected devices has nearly
exhausted the address capacity of IPv4, leading to the need for a more robust system.

IPv6 (Internet Protocol version 6):

● Address Length: Utilizes 128 bits, which significantly increases the number of possible
IP addresses to about 3.4 x 10^38 (2^128). This expansion addresses the limitations of
IPv4 and supports an expansive future growth of internet-connected devices.
● Benefits: Besides providing a larger address space, IPv6 includes enhancements for
security, routing efficiency, and auto-configuration.

Know for AP Exam: 2^96 times as many addresses can be represented with IPv6.

81
Big Idea 4: Computer Systems and Network
TCP and UDP Protocols

TCP (Transmission Control Protocol):

● Functionality: TCP is a connection-oriented protocol that ensures reliable data

transmission between computers on a network. It breaks data into packets,
manages the packet sequencing, and retransmits any packets that are lost during
transmission.
● Use Cases: Ideal for applications where accuracy is more critical than speed, such
as web browsing, email, and file transfers.

UDP (User Datagram Protocol):

● Functionality: Unlike TCP, UDP is connectionless and does not guarantee the
delivery of packets, meaning it does not resend lost packets. This makes it faster
but less reliable.
● Use Cases: Suitable for applications where speed is more critical than reliability,
such as streaming audio/video or gaming, where missing a few packets might not
disrupt the user experience.

Network Fault Tolerance and Redundancy

Fault Tolerance:

● The internet is designed to be fault tolerant, meaning it can sustain operations

even if part of the system fails. For example, if a route between two points on the
internet is disrupted, the data will automatically be rerouted through an alternative
path.

Redundancy:

● Redundancy involves creating multiple pathways and duplicate systems to ensure

reliability and availability. In networking, having multiple routes between sender
and receiver ensures that the failure of a single path does not interrupt data
transmission.

The Internet: Refers to the global network of physical hardware — such as computers,
routers, and cables — that allows billions of devices to connect and communicate.

The World Wide Web: Is a service built on top of the internet. It uses the HTTP protocol
to transmit data and is made up of interconnected web pages and web applications.

82
Big Idea 4: Computer Systems and Network
Understanding Sequential vs. Parallel Computing

When examining computational models, it's crucial to distinguish

between sequential and parallel computing, as each has different
implications for processing speed and efficiency. Here's a breakdown of
these concepts along with a method to calculate the "speedup" achieved
through parallel processing.

Sequential Computing

Definition:

● Sequential computing is a process where operations are performed

one after another. Each step must be completed before the next
begins, resulting in the total processing time being the sum of all
individual steps.

Example Calculation:

● Suppose a task involves the following sequential steps with their

respective times (in seconds): 4, 1, 6, 2, 3, 1, 5, 1.
● Total processing time = 4 + 1 + 6 + 2 + 3 + 1 + 5 + 1 = 23 seconds.

Parallel Computing

Definition:

● Parallel computing involves dividing a task into smaller parts that

can be executed simultaneously on different processors or across a
network of computers. The total time required to complete the task
in parallel is determined by the longest sub-task.

83
Big Idea 4: Computer Systems and Network
Example Calculation of Parallel Processing Time:

● If the same task is split where the longest sub-task takes 9 seconds,
then the parallel processing time is 9 seconds.

Mixed Model Calculation:

● If parallel computing involves some steps that must be executed

sequentially alongside parallel tasks, the total time is the sum of all
sequential tasks plus the time taken for the longest parallel task.
● Example:
○ Sequential tasks: 2, 1
○ Parallel tasks: 4, 3, 1
○ Total parallel processing time = 2 + 1 + max(4, 3, 1) = 3 + 4 = 7
seconds.

Speedup Calculation

Speedup is a measure of how much faster a parallel system is compared

to a sequential system for the same task.

Formula: Speedup = Sequential run time / Parallel run time

Example of Speedup Calculation:

● Sequential time: 23 seconds

● Parallel time: 9 seconds
● Speedup = 23/9 = 2.56
● This result means the parallel solution is approximately 2.56 times
faster than the sequential solution.

84
Big Idea 4: Computer Systems and Network
Understanding Distributed Computing

Distributed computing is a powerful approach used to tackle large and complex

problems that exceed the capabilities of a single computer, particularly in terms of
processing power and memory capacity. Let’s explore how distributed computing
compares to parallel computing and why it's essential for solving certain types of
problems.

Distributed Computing Defined

Distributed Computing:

● Concept: In distributed computing, a problem is divided across multiple

computing devices (nodes). These nodes can be located in the same physical
location or spread across different geographical areas, interconnected via a
network.
● Advantages:
○ Scalability: By adding more nodes to the system, distributed computing
environments can scale to handle tasks of almost any size and complexity.
○ Flexibility: Systems can be expanded or upgraded incrementally, which is
more cost-effective than scaling up a single supercomputer.
○ Fault Tolerance: The failure of a single node does not necessarily prevent
the entire system from continuing its operation. Redundant data storage
and functional backups can keep the system running smoothly despite
individual component failures.

Parallel vs. Distributed Computing

While both distributed and parallel computing involve running processes

concurrently, they differ mainly in their structure and use cases:

● Parallel Computing: Utilizes multiple processor cores within the same

computer to perform concurrent processing of tasks. This is effective for tasks
that require significant processing power but are limited by the physical and
memory constraints of a single machine.
● Distributed Computing: Spreads tasks across multiple, often heterogeneous,
machines which may not share a physical connection but are linked through a
network. This model is suitable for very large data sets and computationally
intensive tasks that no single machine could handle efficiently.

85
 Big Idea 5:
Impact of Computing

Return to Table of Contents

Big Idea 5: Impact of Computing
The Digital Divide

The "digital divide" refers to the disparities in access to digital technologies, particularly
computers and the internet. This divide can significantly impact various aspects of life,
including education, economic opportunity, and social inclusion.

Factors Contributing to the Digital Divide:

● Infrastructure: Not all regions have the necessary infrastructure for internet access,
which can be a significant barrier in rural or underdeveloped areas.
● Education: Access to technology isn't enough if individuals lack the education
necessary to use it effectively. Digital literacy is crucial for maximizing the benefits
of internet access.
● Indifference: Some individuals may have access to technology but choose not to
use it, either because they see no personal benefit or due to cultural reasons.
● Cost: The expense associated with securing reliable internet access and
maintaining digital devices can be prohibitive for many people, continuing the
cycle of the digital divide.

The Impact of Computing Innovations

Computing innovations are technological advancements that incorporate software or

programs to enhance functionality. These innovations can profoundly impact societies,
cultures, and economies, often in complex and contradictory ways.

Dual Nature of Innovations:

● Beneficial Effects: Innovations can improve efficiency, enhance safety, and provide
significant conveniences. For example, GPS technology in vehicles allows drivers to
estimate travel times more accurately, plan routes efficiently, and avoid traffic,
contributing to time management and fuel savings.
● Harmful Effects: The same innovations can have negative repercussions. In the
case of GPS, while it aids in navigation, it can also lead to privacy concerns, such as
unauthorized tracking or data collection by third parties, including law
enforcement or advertisers.

Example: GPS Technology

● Benefit: GPS provides real-time location data, helping drivers navigate unfamiliar
areas, which enhances safety and efficiency on the road.
● Harm: However, if this data is accessed by others without consent, it can lead to
privacy violations and potentially enable unwanted surveillance.
87
Big Idea 5: Impact of Computing
The Impact of Bias in Computing Innovations and the Role of Open Access

Computing innovations are fundamentally shaped by human input, reflecting the

biases of those who create and implement technology. Here’s a look at how biases
can be embedded in computing innovations, the significance of crowdsourcing and
citizen science, and the importance of open access in promoting wider distribution of
information.

Human Bias in Computing Innovations

Influence of Bias:

● Computing innovations, from algorithms to applications, often carry the implicit

biases of their creators. This is particularly evident in machine learning, where
algorithms trained on biased data will inevitably produce biased results. It is
crucial for programmers to actively work to identify and mitigate biases
throughout the development process to ensure fairness and objectivity in
technological outputs.

Mitigating Bias:

● Efforts to reduce bias in software development should include diverse

development teams, rigorous bias testing, and continuous monitoring and
updating of systems to address new and emerging biases.

Crowdsourcing and Citizen Science

Crowdsourcing:

● Crowdsourcing leverages the power of the internet to gather ideas, services, or

content from a large group of people. This model is exemplified by platforms
hosting "idea competitions" and "innovation contests," such as the Netflix Prize
for algorithm improvement or Lego Ideas for new product suggestions. These
initiatives tap into a global talent pool, accelerating innovation and engaging a
broader community.

Citizen Science:

● Citizen science involves public participation in scientific research, allowing

non-scientists to contribute data using their computing devices. Projects like
Folding@Home and Galaxy Zoo enable individuals worldwide to contribute to
complex research tasks, democratizing science and expanding research 88
capabilities.
Big Idea 5: Impact of Computing
Open Access and Creative Commons

Open Access:

● Open access refers to the practice of making research outputs freely available
online without any access restrictions. This approach enhances the visibility and
usability of research findings, accelerating scientific discovery and innovation.

Creative Commons:

● Creative Commons licenses provide a flexible range of protections and

freedoms for authors and creators. These licenses allow individuals to legally
share their work with others, enabling creators to specify how others may use
the work, which can include permissions for remixing, redistributing, and
building upon the work, often commercially.

Examples of Open Source and Open Access:

● Open Source: Software like the Firefox browser and OpenOffice, which are
made freely available and can be modified and redistributed by anyone.
● Open Access: Scholarly articles and databases that are accessible online
without financial, legal, or technical barriers.

Security and Privacy in Computing

Security:

● Protecting the confidentiality, integrity, and availability of information is

paramount in safeguarding data against cyber threats and unauthorized
access.

Privacy:

● Privacy concerns the right of individuals to control their data and restrict its
dissemination to third parties. Measures to protect personally identifiable
information (PII) are critical in maintaining an individual's privacy.

PII Examples:

● Names, social security numbers, biometric records, and any other data that can
uniquely identify an individual.

89
Big Idea 5: Impact of Computing
Privacy, Data Security, and Authentication in Computing

As computing innovations advance, the management of personal identifiable

information (PII) and metadata raises critical privacy and security concerns.
Understanding these issues, alongside the authentication measures used to protect
data, is essential for both users and developers.

Personal Identifiable Information (PII) and Metadata

PII Management:

● Economic Value: PII is a valuable asset that can be analyzed, processed, and
often sold by businesses to advertisers, forming a core part of many companies'
business models. This includes details such as name, address, email, and more
sensitive data that can identify an individual.
● Privacy Concerns: The handling and sharing of PII by companies have led to
significant privacy concerns, particularly regarding how securely and
transparently this information is managed.

Metadata Implications:

● Definition and Examples: Metadata, while not directly identifying an individual,

includes information like
a. Geolocation: Records the location where a digital photo was taken or
where a phone call was made.
b. Time Stamps: Indicate when a file was created, modified, accessed, or
when an email was sent.
c. Device Identifiers: Include information about the device used to take a
photo or send a message, such as the make and model of a smartphone
or camera.
d. File Metadata: For documents, this can include the author's name, the
organization, document length, and sometimes the network name or
machine ID from which it was created or modified.
e. Note: They might try to trick you by asking you for an example of
metadata and one of the options is the picture itself. That is not part of the
metadata.
● Impact: This data can be used to track user behavior and preferences, often
without the user's explicit consent or awareness, leading to potential misuse
beyond the intended use envisioned by developers.

90
Big Idea 5: Impact of Computing
Authentication Measures

Purpose and Importance:

● Goal: Authentication measures are crucial for protecting devices and digital
assets from unauthorized access, ensuring that only verified users can access
sensitive information.
● Implementation: Effective authentication methods help safeguard against
unauthorized data breaches and cyber attacks.

Types of Authentication:

1. Passwords:
○ Criteria: A strong password is crucial for basic security hygiene. It should
be memorable for the user but complex enough to resist guessing or
automated attacks.
○ Best Practices: Use a mix of upper and lower case letters, numbers, and
special characters to increase password strength.
2. Multi Factor Authentication (MFA):
○ Mechanism: MFA enhances security by requiring multiple forms of
verification before granting access. This typically involves two or more of
the following:
■ Knowledge: Something the user knows (e.g., password, PIN).
■ Possession: Something the user has (e.g., a mobile device, security
token).
■ Inherence: Something the user is (e.g., biometric data like
fingerprints or facial recognition).

Enhancing Security and Privacy

Strategies to Protect Data:

● User Education: Educating users on the importance of strong passwords and

the benefits of multifactor authentication can significantly reduce security risks.
● Data Minimization: Companies should collect only the data necessary for the
specified purpose, reducing the risk associated with data breaches.
● Transparency and Consent: Clear policies on data use, along with explicit user
consent for the collection and use of data, are vital for maintaining trust and
compliance with privacy laws.

91
Big Idea 5: Impact of Computing
Digital Certificates and Certificate Authorities

Digital Certificates:

● Digital certificates are used to validate the ownership of encrypted keys that
enable secure communications between parties. They serve as a form of
identity verification for websites or entities engaged in digital transactions or
communications.

Certificate Authorities (CAs):

● CAs are trusted entities that issue digital certificates. They confirm the identity
of the certificate holder and associate that identity with a public key. In the trust
model, CAs play a crucial role in ensuring that communications and
transactions are secure and that the entities involved are verifiably trustworthy.

Encryption: Securing Communication

Encryption:

● Encryption is the process of converting data into a format that can't be read by
unauthorized users. Cryptographic algorithms are used to transform plain text
into encrypted text, which is known as ciphertext.

Decryption:

● Decryption is the reverse process, where ciphertext is turned back into readable
data using a key.

Types of Encryption:

1. Symmetric Key Encryption:

○ Uses the same key for both encrypting and decrypting data. The key must
remain secret and is shared between the communicating parties.
○ Example: AES (Advanced Encryption Standard) is widely used for secure
data transmission that requires symmetric keys.
2. Public Key Encryption (Asymmetric Encryption):
○ Involves two keys: a public key, which anyone can use to encrypt data, and
a private key, which is kept secret by the owner and is used to decrypt
data.
○ Example: RSA (Rivest–Shamir–Adleman) is a common asymmetric
encryption algorithm used for secure data transmissions. 92
Big Idea 5: Impact of Computing
Malware: Understanding the Threat

Definition of Malware:

● Malware, or malicious software, is any software intentionally designed to

cause damage to a computer, server, client, or computer network. This
includes viruses, worms, Trojan horses, ransomware, and more.

How Malware Spreads:

● Malware can be spread through various means, including email

attachments, executable files, instant messaging, social media, and even
legitimate-looking freeware or shareware.

Computer Viruses:

● A subset of malware, computer viruses are programs that can replicate

themselves and spread to other devices. They often attach themselves to
clean files and can spread uncontrollably, damaging a system’s core
functionality and deleting or corrupting files.

Security Practices to Counter Threats

1. Use of Digital Certificates:

○ Implementing digital certificates ensures that communications are
secure and that the entities involved are authenticated, minimizing
the risk of interception by malicious actors.
2. Employ Robust Encryption Methods:
○ Utilizing both symmetric and asymmetric encryption can help
secure data transmissions against eavesdropping and other forms of
cyber attacks.
3. Regular Updates and Malware Scans:
○ Keeping software up-to-date and performing regular malware scans
can protect against known vulnerabilities and malware infections.
4. Educate Users:
○ Educating users about the risks of suspicious files and links can
reduce the chances of malware infection.

93
Big Idea 5: Impact of Computing
Understanding Unauthorized Access and Common Cybersecurity Threats

Unauthorized access to computers and networks poses a significant risk, potentially

leading to data breaches, financial loss, and compromised personal information.
Several methods are commonly employed by cybercriminals to gain such access:

Phishing

Phishing Explained:

● Technique: Phishing involves tricking users into providing sensitive information

by masquerading as a trustworthy entity in electronic communications.
● Method: Typically executed through emails that appear to be from legitimate
sources, such as banks or popular websites, but can also occur via fake websites
that ask users to input personal details.

Prevention Tips:

1. Verify the Source: Always check the sender's email address and the URL of any
links included in the message to ensure they are legitimate.
2. Do Not Click on Suspicious Links: Avoid clicking on links in unsolicited emails
or messages.
3. Use Anti-Phishing Tools: Employ email filters and browser security tools that
help detect and block phishing attempts.

Keylogging

Keylogging Explained:

● Technique: Keylogging involves the use of a program or a device to record the

keystrokes made on a computer without the user’s knowledge.
● Purpose: It’s primarily used to capture sensitive information like passwords,
credit card numbers, and other personal data.

Prevention Tips:

1. Use Trusted Security Software: Install comprehensive antivirus and

anti-malware software that can detect and block keylogging software.
2. Update Regularly: Keep all software updated to protect against vulnerabilities
that could be exploited by malware.
3. Employ Virtual Keyboards: For entering sensitive information, use virtual
keyboards to circumvent keyloggers. 94
Big Idea 5: Impact of Computing
Data Interception via Rogue Access Points

Rogue Access Points Explained:

● Definition: A rogue access point is a wireless access point installed

on a secure network without the network administrator’s consent. It
can be used to intercept data transmitted over the network.
● Risk: These devices can capture unencrypted data sent between
computers and the network, allowing attackers to eavesdrop and
potentially alter the data being communicated.

Prevention Tips:

1. Monitor Network Hardware: Regularly check for unauthorized

devices connected to your network.
2. Secure Wireless Networks: Use strong encryption (WPA3, if
available) for Wi-Fi networks to protect against unauthorized access.
3. Educate Employees: In a corporate environment, educate
employees about the importance of securing their devices and the
dangers of connecting to untrusted networks.

95