Expectations

Learning Targets

• I can disassemble and reassemble a computer.

• I can describe the function of basic PC components.

Assessments

• You will be asked comprehension questions to identify parts of a computer from their images, what their primary purpose is, and what their common problems are

• You will be observed disassembling and reassembling a computer and checked that you can identify all the components and that you can reassemble the machine correctly

Components

Imagine a person juggling while singing an old song from their childhood. Part of the juggler's brain is tracking the motion of each ball and the timing of each throw. Another part of the juggler's brain is recalling the song. His stomach is fueling his muscles. His nervous system is communicating controls from his brain to his arms. His eyes are taking in information. His voice is outputting the song. We'll use this as a reference as we go over hardware.

Central Processing Unit

Description

CPUs or processors do math. They are a super complex series of logic gates made unbelievably small. What are logic gates? Imagine a wire with two light switches in a row. Since both switches are on the same wire, both need to be flipped to the ON position in order for power to flow through the line. That's an AND gate. If the wire split into two instead and each fork had its own switch, that would be an OR gate as only one or the other has to be enabled for power to flow. Processors have millions and millions of these complex arrangements made in microscopic sizes.

According to our analogy, the CPU is the part of the juggler's brain that's calculating the path of each ball while also managing all the other signals through his brain. It doesn't cover all the functions of the brain in our analogy, but it is at the center of the comparison.

Problems with CPUs

CPUs use a lot of power and generate heat. Metal wires create a little resistance as electricity flows through them and that energy turns into heat. You must manage the heat that gets created by your CPU using a fan or other cooling system. If your computer collects a lot of dust, it will insolate

If a CPU is older it means it could be generating more heat while executing fewer commands. And if the CPU is slow, that means it must be connected to a whole bunch of other parts that are older and slower too.

Extra Information

In case you're curious and don't mind a little challenge, learn about the Von Neumann Bottleneck and how computer engineers have gotten around it.

Random Access Memory

Motherboard

Hard Disk Drive

Power Supply and Case

Peripheral Devices

Additional Practice

• Look through Tom's Hardware and read how the experts recommend you shop for components

• Create a Quizlet set and practice these terms

APIs Make Life Easier

No one writes code totally from scratch. All programmers use a variety of preexisting systems that allow for easier development. We write code that interacts with other layers. That's an API or Application Program Interface. We can interact with our operating system, helpful resources or other apps.

BIOS

The BIOS or Basic Input/Output System is firmware. It's something built right into your motherboard. It helps boot your computer up and gives something for the operating system to run off of.

Operating System

The OS is a big deal. It serves as a vital intermediary between software and hardware. Instead of having to program every little operation for each device in our computer, we can just use the commands provided by the operating system.

Interpreter

The interpreter allows us to execute our written Python code. It's our interface with the Operating System which is in turn interfacing with our hardware.

Libraries and Packages

Part of what makes Python so great are all the tools and frameworks available. Want to build a web application? Use Flask or Django and you'll be up and running in minutes. Do you want tools for data analysis? Machine learning? Robotics? There's an ocean of open-source tools ready to give your app superpowers.

Expectations

We're going to take a tour of Python. You are expected to know generally what these things are, you're not yet expected to know how to use them. So no freaking out. We'll play around with some fun projects after a quick look around.

Learning Targets

• I can make a hello world app in Python.

• I can differentiate between compile-time, run-time, and logic errors.

• I can describe the basic constructs of programming languages such as variables, conditionals, loops, and flow control.

Assessments

• You will be answering comprehension questions about the layers supporting software execution.

• You will be creating and submitting your several small Python apps using trinket.io

Let's go to trinket.io and build some simple stuff, starting with print("Hello, world")

We'll go over each of these concepts in greater detail. For now, let's skim over all the big topics.

Class Videos

The first video deals with the following concepts: Functions, Variables, Operators and Conditionals

Class 1/4

Class 1/11

Class 1 / 20: User defined functions

class 1/24: for / while loops

Key Concepts

Data Types

The first thing we'll tinker with is declaring variables and storing information. Variables in Python are dynamically typed, meaning you can store one type of information in a variable and then switch it without any fuss. Other languages are more strict and don't allow such shenanigans.

Operators

We use math symbols for most common operations. But Python has some cool operators. Read!

Conditionals

Conditionals control how the program flows based on input from the user (in an app) or sensors (on a robot.

Expectations

Learning Targets

• I can interpret an unfamiliar code base.

• I can extend the code to my own project.

Assessments

• You will create an interactive program or game based on existing turtle classes

• You will be asked regular comprehension questions about Python.

First Class Assignment (CodeHS.com)

Adding Moving Turtle

from turtle import Turtle


class ClassName (Turtle):
    def __init__(self, starting_x, starting_y):
        Turtle.__init__(self)
        self.starting_x = starting_x
        self.starting_y = starting_y
        
        # General setup
        # self.color("black")
        # self.penup()
        # self.shape("turtle")
        # self.goto(self.starting_x, self.starting_y)
        
    def method_example(self):
        pass
        ## change the name and make the method work

Assignment and Rubric

Create an interactive turtle application of your own design. This can be a game or other interactive program, but it must use at least two of the three types of turtle classes we have outlined (moving turtle, keyboard turtle, clickable turtle).

• 3 pts - Program works without errors

• 3pts - Program uses two classes of turtle

• 3pts - Program is interactive. Users can DO something with the program beyond what we set up in class. Make sure your theme is cohesive!

• 1pts - Program is cleaned up (unused imports have been deleted, for example)

How do I...

...make multiple things move?

...write text on the screen?

...stop movement with walls?

...make a ball move diagonally and bounce off multiple sides of the room?

... create a background image and have it change later?

...set up and check a timer

...add a start screen

...Save a High Score in a File?

... add points from different objects to a single score?

... get objects to check each other for different properties?

...find the x and y position of my mouse on the screen?

...create a custom shaped turtle?

...create a multi-colored turtle?

Class Videos

2/1

2/2

2/7 assignment PT 2

2/7

2/9 -- Extending the SuperTurtle APP Assignment

To finish off the superturtle app, we are going to add the following to our program:

• Move the printing of the menu options to the helper function, but run it in main.py (2 points)

• Add four_square to the menu options (you should have 1. add turtle, 2. star, 3. four square at this point) and make them execute when called. (2 points)

• Add at least 3 new methods to the SuperTurtle class (whatever you want, but they should be obviously different than the things we wrote together.) Add the methods to the main menu and make sure they execute when called. (9 points)

• Make sure you have a creative display! (2 points)

Daily Lessons

Wordle with Turtles Assignment

In order to complete the Wordle program, there are a few things you need to add:

• Make a new method in GamePlay.py which can be called during process_input() with different colors in the different letter situations. Keep your code D.R.Y. (4 points)

• Complete the check_game_end() method in Gameplay.py and implement checks throughout your game. Make sure the game actually ends -- remember we have a boolean which controls the end of the game in main.py. (4 points)

• Make sure your settings variables are all implemented within your program (for example: when you change background value to a different color, it actually makes the change in your program). (2 points)

• Add a minimum of twenty 5 letter words to your word list. (1 point)

• Clean up your code. Get rid of methods or imports you didn't use. (1 point)

Expectations

Learning Targets

• I can implement the basic constructs of programming languages such as variables, conditionals, loops, and flow control.

• I can make a class wrapper that inherits from a library's class.

• I can call a method from a library.

Assessments

Class Videos

Class 1/24 Turtle drawing assignment:

What is DRY code?

Loops and functions allow skilled programmers to make more efficient code that's easier to maintain.

Parts of a for loop

A for loop has an iterator and a collection that it traverses.

Parts of a function

A function has a definition that lists any parameters and has a code block underneath that gets activated when called.

In the example above, the magic_spell function isn't a part of a Class. It's on its own. If that ability was a part of a player in a game, we'd call it a method instead of function.

Code Along

We're going to jump into work with a lot of advanced concepts. This is intentional. New programmers are very often intimidated by code they don't understand. I want you to get used to that early on. Enjoy tinkering with a few lines here and there and see how things change. Get comfortable swimming in the deep end.

This class (inherits) from the Turtle class which is available since we imported the turtle library. Instead of writing from turtle import Turtle I could have also written just import turtle in which case every time I wanted to use the Turtle class, I would have had to specify the library, such as turtle.Turtle()

The only thing that our SuperTurtle does that the regular Turtle doesn't is the way it gets constructed. When a new Turtle is created or instantiated, we initialize or __init__ with some default properties.

Follow along as we go over a couple of skills. You aren't expected to be able to do this stuff yourself quite yet.

1. Make a loop and create a bunch of turtles

2. Add a new method to the turtle to make it go to a random location and call that method in the constructor

3. Make a list of colors and make each turtle randomly select a color

4. Make an empty list and add each turtle to the collection as it's being instantiated

5. Loop through the turtle collection and modify each

We'll spend some time experimenting with this code, learning by modifying existing code.

Building Methods

A method or function is a group of commands that can be called. If I tell you to please clap, that's me activating or calling the command that's already defined in your head. I may give you additional parameters or arguments like, "clap 5 times loudly". In Python that may input("What's your name?") but that doesn't save the variable, so we write it as:

name = input("What's your name?") written as joe.clap(5, "loudly")

What's the difference between a function and a method?

They both start with def and will execute their pre-programmed commands when called. However, we'll refer to a function as something floating outside of a class and a method as an ability built within an object. For example, a method would be if an instance of the Human class, let's call him Joe, had to sneeze: joe.sneeze(). But a function would be an anonymous helper like therancolor() function programmed above that just returns a random string in a list of colors.

Novel Design

Look at the documentation, other student examples, and Google searches to modify open-source code and customize your own design. You can use one or many turtles but the end result has to have multiple colors over a fun design.

Taking Controls

Let's make our app more interactive. Just like the print("message") function we've been using, there's another one that takes a string input called input()

input("What's your name?") will work but that doesn't save the user's response anywhere. So let's create a variable that will store the answer in this example:

name = input("What's your name?")

Testing the input

To make sure we are asked the question over again, we'll put the input within a while True: loop.

Expectations

Learning Targets

• I can describe a brief history of the Internet's origin and impact.

• I can write a professionally formatted email.

Assessments

• You will receive comprehension questions about why the Internet was made, the very basics of its technology, how the technology grew, and its significance to society.

The Idea

The Internet is mankind's greatest achievement. Mr. Adiletta takes a dramatic position on the Internet as a basic human right. The evolution of human intelligence goes beyond the growth of our brain. and into the development of communal stories, into libraries, and then into the Internet. The Internet is a product of human evolution and is the birthright to all people.

The Internet is a part of your mind and you have the right to use your brain.

Why was the Internet created?

Did Al Gore create the Internet?

In his 2000 Presidential campaign, Al Gore rightly took some credit in the creation of the Internet. No, he did not help develop the TCP/IP network. However, after the ARPANET project was complete, the ownership of the underlying technology was in question. It was offered for sale to at least one telecommunications company but they passed on buying the Internet not knowing what it would be good for. Al Gore was a part of a congressional effort to make TCP/IP a public resource. No one owns the Internet because of that. He also helped establish support to connect people--something we have a moral obligation to continue.

Significance of the Internet

Why is this video funny?

After watching this video, take a moment to think about why this video seems silly. It's not just her rockin' hair and vest or the British perspective of the American president. It may be the many, giant screens. But more specifically it's how the changing technology has changed our impressions. She talks about shopping on the internet as a future possibility and not something that everyone does like it's no big deal. Again, take a moment to understand that the Internet is a big deal.

The Internet has a physical component that must be appreciated, too.

Vocabulary

• OSI model: The basis of the Internet. This describes how the TCP/IP network started by the Defense Department has evolved.

• Domain Name System (DNS): A sort of phone book that changes or resolves domain names into IP addresses

  • A Record: routes primary domains like google.com

  • C Record: routes subdomains like mail.google.com

  • MX Record: routes email addresses. That's why emails @gilmour.org go to a different server than what's hosting the website at gilmour.org

Further Exploration

There are many free tools that help you learn about domains. These are very helpful for web designers as you may want to check on the current host of a client interested in a site redesign. Try looking up the record of a few domains using one of these tools:

Expectations

Learning Targets

• I can connect to my Raspberry Pi via SSH.

• I can deploy an app to a Raspberry Pi.

• I can compose a higher-ordered algorithm.

• I can update code on my Raspberry Pi.

• I can make short, descriptive commit messages.

Assessments

• You will submit a link to your GitHub repo.

• You will demonstrate your capacity to control your robot.

• You will be asked regular comprehension questions about Raspberry Pis.

Terms

Printed Circuit Board (PCB)

​

Single Board Computer (SBC)

This is a PCB with all the basic components found in a personal computer (PC)

Getting Started

Fork code

2. Open Replit and start a new project from github

3. Use your forked github project. You should now see your code on your editor. Explore student.py and teacher.py.

5. Open putty and enter the ip address of your robot. Click open.

   • login: pi

   • password: robots1234

6. Remove the Piggy folder if it's already there: rm -rf Piggy

7. Now we'll clone your project on the robot too with git clone https://github.com/YOURUSERNAME/Piggy

8. Change to your project folder: cd Piggy

9. Run the app: python3 student.py

Push code to GitHub

Whenyou make changes to your app and want to update the code on your robot, we first need to send the code from our computers to GitHub. This happens in the version control tab by typing in "What did you change" and hitting Commit & Push.

Pull code on robot

Now we'll remote control our robots using SSH. We'll use Linux commands to pull the updated code down from GitHub.

Open putty and enter the ip address of your robot. Click open.

• login: pi

• password: robots1234

Note: You will not see the password when typing. This is a security feature!

1. Make sure you're in the right folder: cd Piggy

2. Pull your updated code: git pull origin master

3. Run your app: python3 student.py

4. If it doesn't run, study the error.

Calibrate

We'll need to configure your class variables.

Midpoint

Motor Speeds

Sometimes one motor will perform faster than the other, giving the robot a noticeable veer. We can try to correct for this drift by adjusting the motor power.

Moving Your Robot

Dance Project

Check out what commands are available from the API that's provided for you. These are the commands you're inheriting.

Higher-Ordered Logic

Your dance method should read as close to regular English as possible. The nitty-gritty commands are all kept in the particular methods being called in your dance algorithm. So your dance method should just call a handful of moves. Within those moves, you'll use the specific motor commands below and get into the nitty-gritty of robot control.

• deg_fwd(angle) - how many degrees do you want your wheels to rotate? You need to pass the angle

• turn_to_deg(angle) - rotates to the given angle as calculated by the piggy's gyroscope

• turn_by_deg(angle) - turns relative to it's current heading. Positive values rotate right and negative rotate left

• fwd - powers on your robot to drive forward. You'll need to use self.stop() to power off the motors

• right - by default, self.right() will give the left motor 90% power and the right 0% which rotates right. You can use kwargs to adjust the power such as self.right(primary=90, counter=-90), which will spin the robot in place

• left - same as right but reversed.

• back - same as fwd but in reverse.

• servo - moves the servo (plugged into servo1) to the given value (use 1000 - 2000)

• stop - sets motor power to zero

• read_distance - returns the distance from the distance sensor (plugged into I2C port) in millimeters

• get_heading - returns the gyroscope's value

Shutting down the robot

To shut down your robot, type: sudo shutdown now in the putty window.

Basic Movement Methods

• Square

• Dance

• Add safe_to_dance() method which checks surroundings and only dances if it has enough space.

• Move to wall and stop

• Move to wall and turn around. Move forward again and repeat endlessly.

• Move to box and go around it

• Before moving around box, figure out which side of closer. If you are closer to the left end of the box, go around left. If you are closer to the right end of the box, go around to the right.

Intermediate Movement Methods

• Write a move method which scans slightly to the left and right of the robot as it moves forward.

• If it senses a wall straight ahead, it goes around to the closest side as above (put that move in it's own method)

• If it senses a wall at the edges of the robot, swerve slightly to miss the wall (this swerve should again be in it's own method).

Maze Navigation

• Coming soon.

Expectations

Learning Targets

• I can describe how web pages are displayed on my browser using HTTP and HTML.

• I can create a basic HTML page.

Assignments

• You will construct an HTML page from scratch in a guided class activity.

• You will complete HTML and CSS courses on codecademy.com

World Wide Web

Tim Berners-Lee

If one person had to be named as the creator of the Internet, it might be Tim Berners-Lee in 1989. More specifically, he created the World Wide Web while working at CERN. It was a way of transferring information over the TCP/IP network talked about in last chapter.

No more Microfiche

The "Internet" we think of is primarily the contents of our web browser. Trying to find information by tediously scanning film after film was not fun. People like Tim Berners-Lee wanted to link text together. So touching one word might connect you to relevant information without having to manually search for hours.

The most important part of a website remains the hyperlink.

HTTP sends HTML

HyperText Transfer Protocol is a set of rules to pass information (like the HTML layout of a web page) over a network. HTML is a markup language. It describes the structure and content of a page. So when you type in an web address like google.com into your browser, you're sending a GET request to the Google server. It responds with an HTML package that your browser renders into a familiar display.

Structure of HTML

Tags and Elements

A tag looks like this: <tag> </tag> The stuff that's between the opening <tag> and the closing </tag> is what's inside that element. The first and most important element in a web page is a hypertext link. If I wanted to make a link that went to Google.com, it would look like this: <a href="google.com">this is my link</a>

The term tag describes the structure of the <opening> and </closing>. The element is what type of object is being built by the tag, (an a is a hyperlink). The contents of an element is whatever is between the open and closing tag of an element. The property="value" pair that goes inside of an HTML tag is called an attribute.

Page Structure

Every web page has to have a <!DOCTYPE html> at the very start to tell your browser that yes, this block of text is HTML and it should render it into a display. The <html> element does something very similar. Every page you've ever seen online has been the contents of an HTML tag.

<!DOCTYPE html>
<html>
<head>
<title>Page Title</title>
</head>
<body>

<h1>My First Heading</h1>
<p>My first paragraph.</p>

</body>
</html>

The <head> element isn't seen by the user. The contents of the head allow you to connect other resources to the page, such as fonts or CSS.

CSS is HTML's Sidekick

CSS has its own style rules. But you drop it into an HTML head like any other HTML, <style> css goes here </style>. You can put the CSS in the HTML file, but the better way is to keep your CSS in a separate file. In that case, you use a <link> element instead to connect the .css file.

Practice

Additional Training

How do I...

...make multiple pages in a kivy app.

Learning Targets

• I can build a professional-caliber file system.

• I can collaborate with my team through a KANBAN board.

Google Drive

While often used for online storage, Google Drive's offline functionality unlocks its potential for design projects. You and your team can work on Adobe AI and Photoshop files without an internet connection by enabling offline access. Shared folders within Drive serve as central hubs for exchanging design files and planning materials like Google Docs. This seamless collaboration ensures everyone stays on the same page, regardless of location or internet availability. This technique is crucial for delivering professional-caliber design work in a collaborative environment.

• ProjectName

  • Loose in the folder can be branding documents, collections of text in Google Doc and other guides.

  • STOCK

    • Collect images from allthefreestock.com and other sources. These are raw images that will need to be resized and possibly color-treated.

  • HTML

    • Any coding elements get stored in this folder

  • IMG

    • Edited images ready for the web.

  • LOGO

    • Adobe files and your logo package

  • RESEARCH

    • Collect relevant articles, screenshots of other websites for comparison, etc.

KANBAN

Initially developed by Toyota to optimize manufacturing, KANBAN boards have become a popular project management tool across various industries, including design. Their simplicity lies in their visual, three-columned structure: Backlog, In Progress, and Done. This straightforward visualization aids communication and transparency, allowing every team member to grasp the project's status at a glance. KANBAN's power lies in its ability to manage project flow. Tasks move from Backlog to In Progress, signifying active work. Once completed, they shift to Done, signifying progress and freeing up space for new tasks. This system prevents overloading team members and keeps complex projects manageable, even for large-scale design endeavors. Whether collaborating remotely or in person, KANBAN boards ensure transparency, focus, and continuous project flow, propelling your design project toward successful completion.

Every Trello card is a vital piece in our project puzzle. Here's what makes a great one:

Title: Keep it simple and descriptive. Focus on the problem, not the solution ("Broken Link on Homepage" versus "Update Header Navigation").

Description: Explain the issue itself, avoiding descriptions of actions taken. Let the details flow freely so others can understand the scope of the problem.

Visuals: Paint a picture! Paste screenshots directly onto the card to clearly illustrate the issue and where it occurs.

Teamwork: Ensure the right team is aware. Tag the appropriate team members who can tackle this specific problem.

Backlog to In Progress: When the card is ready for action, drag it to the "In Progress" column. Now's the time to assign ownership! Choose the individual(s) directly responsible for working on the issue, not the entire team.

Progress Tracking: Before marking the card "Done," log your activity in the comments section. Share screenshots, code snippets, or any relevant updates to document your progress.

Time Transparency: Be kind to your future self (and colleagues)! Track your work in 15-minute increments. This detailed time log will prove invaluable when creating project invoices.

Remember, clear and concise Trello cards are the key to smooth communication, effective collaboration, and, ultimately, project success. Let's build clear cards and conquer those sprints!

Example Cards

You'll have to make your own cards, but here's some starting ideas:

We'll be using Trello to track your progress and to coordinate a team project. Each task or card must be a specific task that can be achieved preferably within a class period or at least within a week. The measurement or proof of that task's completion should be described in the activity log entry of that Trello card.

Learning Targets

• I can describe the difference between raster and vector.

• I can describe the difference between serif and sans serif.

• I can iterate on my design.

• I can use Photoshop's masking layers and quick select tool.

• I can create a logo in Adobe Illustrator.

Serif vs Sans Serif

One of the first decisions to make when starting a new project is your font selection. It helps set a lot of the tone for your site. Typically, I select a header font and a body font--something fun for titles and something easy to read for my paragraphs.

Color Palette

Another key mood-setting decision to make is the type of colors you'll use around your site.

Once you've selected your colors, we're going to add a note to your custom CSS like so:

Call to Action

Raster VS Vector

If your image has been zoomed in or stretched too far, and it's a rasterized image, you'll notice the pixels that make up the image. That's a problem. But the solution is not to use a super high-resolution image with a big file size. That'll just make your webpage take forever to load. We need the right resolution each time.

Use vector where you can. Raster, if the image is the right resolution, looks great. The image below can confuse students into thinking raster is always blurry.

Design Principles

Common Mistakes

1. Navigation that isn't simple, logical and explanitory

2. No clear calls to action

3. Insufficient contrast between text and background or clashing colors

4. Jumbled, unengaging, or unorganized content

5. Clutter

Mostly Boring

Backgrounds and most colors should NOT try to grab your attention. Most of it should be steady, comfortable patterns. Subtly is hard for students eager to splash bright colors on the page. That's why we study examples of great pages. Look how chill most of their decisions are... it makes the touches of bright color really exciting.

Parallelism

Brains love patterns and it can hurt when they're broken. Patterns exist in grammar, color, lines and all sorts of other things too.

Keep Room to Digest

Less is more.

When something is considered "clean" design

Metro, Material and Flat Trends

There is a constant variation in what's trending in web design styles. Here are three of the most popular. The last, flat, is more related to colors and icons and less known as a style.

Photoshop

Photoshop works with rasterized images (as opposed to vector images). Let's discuss the difference first.

We're going to learn about three basic skills:

Layer Masks

Resizing

Our themes typically come with images perfectly formatted for the area. Instead of taking a new image and trying to crop and adjust it into the right size, I simply edit the original image in Photoshop. Once it's open, I'll drag and drop the new one on top of that.

Color Correction

We add in new adjustment layers to tweak colors. Turning down the brightness on a hero image so that it lets your CTA stand out more is a common technique.

Logo Design in Illustrator

Requirements of a Logo Package

• PNG and JPG images

• Wide but thin logos (banner format)

• Square shaped logos

• Large, medium and small file types

• Original .ai files as well as exported versions

• Reversed colors for dark backgrounds as well as light backgrounds

Find a Tutorial

Find a tutorial that gets close to the effect you want. Follow along and then try to tweak and customize it.

About the Test

1. Multiple choice: 40 questions, 90 minutes, 50% of your score

2. Free response: 4 questions, 90 minutes, 50% of your score

Links and Resources

Software

Great Books

Online Courses

Practice Problems

Java Tutorials and References

Learning Targets

• I can use common String methods to modify a string.

• I can evaluate the contents of a String.

• I can use a Scanner to take inputs.

• I can isolate an object in the user's input and use it in Magpie's response.

Magpie Lab

CollegeBoard used to have three official projects, Magpie, Elevens, and PicLab. A few years ago, they dropped those four and started four new ones: Celebrity, Consumer Review, DataLab, and Steganography. But I still think Magpie is the best lab for starters.

What's a magpie?

A bid that can mimic speech.

Check out the chatbot in Activity 1:

Strings

Strings are a special data type in Java. They're not primitives but they behave a little differently than most instantiated objects. In many ways, they're an array of primitive char objects. The biggest difference is that Strings also have many helpful methods to change their formatting, to search and examine the Strings, and lots of other helpful tools.

StringExplorer

Create a new class in our project called StringExplorer and drop this code in:

Activity 2 Starter Code

Now we're going to add a few new classes to the project.

Magpie.java

Now write a commit message to bookmark these changes and push the new version to GitHub. Then following along with the exercises in Activity 2.

Activity 3: Better method

Magpie's current structure and use of .indexOf("something") >= 0 is full of logic errors. It's caps sensitive, it can't tell if you've entered no response at all, and it sees the word "no" inside of "know". Let's do better.

Now we've got to update our getResponse method to use this instead of indexOf.

Let's use this chart to walk through what's happening:

Activity 4: Slice and dice

Let's use parts of the user's message in our response. Read the details in the student guide. Before proceeding.

Replace the else in our getResponse method with the following code:

Now below this getResponse method, let's add in a few methods that are being called by the code above.

Okay, now you're ready to follow along the student guide with the class and ask some questions along the way.

Chatterbots

Your team will build a chatbot that will enter into a conversation with other chatbots built in class.

Step 1: Duplicate and rename example

Next, we need to rename the file and the class.

Step 2: Instantiate bot

Now that you've created your robot, you can add it to the main method.

Step 3: Meet requirements

• File

  • 1 point: Your file has an original name that matches the name in your class definition

• name

  • 1 point: Returns a one-word name that roughly matches your class name

• greet

  • 2 points: Returns a 25 - 100 word opening statement.

  • Bonus +1 point: Randomly selects from at least three opening statements

• respond

  • 3 points: Checks for three different antagonistic words and does not complete the respond method but instead calls the antagonize or pacify method instead

  • 3 points: Checks for three different pacifying words and does not complete the respond method but instead calls the antagonize or pacify method instead

  • 5 points: Searches for at least five keywords and responds to the given subject matter.

• antagonize

  • 3 points: Searches for at least three keywords and responds in a negative tone to the given subject matter.

• pacify

  • 3 points: Searches for at least three keywords and responds in a positive, disarming tone to the given subject matter.

• BONUS POINTS

  • Have your greet method randomly select from at least three opening statements

  • Successfully use substring on the given prompt/statement

  • Your bot successfully adapts to antagonistic or pacifying messages from other bots

Review

Let's review some basics before we move onto our next, advanced concept. Now's the time to hit codingbat, SoloLearn, Codecademy, or other training websites to practice. You want the basics down pat so you can focus on new concepts as we move forward.

Learning Targets

• I can describe the benefits of using the JRE.

• I can identify the three types of errors when programming.

• I can describe the attributes of Java’s main function, including scope, instantiation, and return value.

Java is Portable

Java's strength is also its greatest weakness. The JVM allows the same Java code to run on almost any machine. It does this by hosting a virtual machine, a simulated computer system that facilitates the interpretation of your code.

Respect to Dennis Ritchie

With his partner Ken Thompson, Dennis Ritchie solved a very big program for programmers. It's hard enough for programmers to design an app. It's just crazy if you have to program an app in assembly, telling the CPU and RAM how to handle each and every little operation. Programming languages like Ritchie's C allow coders to focus more on the app and less on how it has to interact with the machine. It's like the first, really powerful book of spells made for magicians.

Just in Time

When you install an app on your computer, the JIT will interpret the developer's code and set it up to run on the given machine. The install process takes longer and it might not be compatible with every machine, but then the app is ready to run very quickly. Java doesn't play like that. Instead, it interprets the code in real-time while running through a virtual machine. So while it can run pretty much everywhere, there's a bottleneck in how fast it can perform.

Extra Information

Editing Code

Three types of errors

1. Syntax or Compile-time: You can't compile this code. Something is way off and Java won't touch your mess.

2. Runtime or crash: Something breaks while it's running as if you asked the computer to divide a number by zero.

3. Logic: Everything runs okay. Nothing crashes. However, the answer you get is just wrong. If your app says 4+4 is 10, you've got a logic error.

Java's Code Structure

In Java, all code must be written inside methods, and all methods belong to a class. This means that every Java program is essentially a collection of classes, each containing methods that define the behavior of your program.

• Classes must be defined inside a file that shares the exact same name as the class. For example, if your class is called MyProgram, then the file must be named MyProgram.java.

• The entry point of every Java program is the main method, which tells Java where to begin executing your code.

Java's Main Method

Every Java app starts the same way, from a static method that returns nothing. Let's introduce these concepts now. Many of these ideas will seem strange, but they'll make more sense as you build up your background knowledge. You'll come back to this section later on and smile. But for right now, let's take a plunge into the deep end of the pool. We'll hurry right back to the basics but let's take a peek at how all Java apps start. public static void main(String[] args){} <=[ all Java apps start from that method! ]

Scope

Who can access this method or this variable? The main method must always be public because it's being triggered from outside the class.

Instantiation

Does this method belong to an instance of the class? What's the difference between an instance and a static class? Imagine we're building a game. We've got one file or class that describes a player and another that has helpful functions like drawing a random number. Every person that plays the game gets their own instance of the player class. It tracks each player's health and abilities in the computer's memory. But the helper class can be static, just one master copy--no instance needed.

Return Type

As the method closes, does it return anything? If so, what type of data is returned? The main method must always return void because it's the point of origin--there's nothing to return data to.

We program little turtles to dance on the screen then we play with real robot cars. Learning how to program is an awesome time. I love my job.

Acceptable Layer of Abstraction

For the people that say "I'm not good with computers"

Computer Science may be intimidating but like any other field of study, you don't have to learn it all at once. We're skipping so much in this class. Don't worry about it. You'll have enough tools to figure out if you want to invest the time to learn the deeper, more challenging (and more powerful) stuff.

You need to know about the pieces, even if you don't know exactly how they work.

In order to understand basic computer programming, you will need to understand some of the components in your computer. If you understand the basic shape of the environment, the behavior of programming languages will have better context. You won't need to understand exactly how a processor works, but you'll need to know roughly how it fits into the picture so you can solve some common problems.

Links and Resources

Software

Free Code Training

• Solid: https://sololearn.com

Expectations

Learning Targets

• I can connect replit to my github repositories

• I can clone an existing repository, fork it, and extend the code to my own project.

Assessments

• You will submit a link to your GitHub repo.

• You will create a game based on existing turtle classes

• You will be asked regular comprehension questions about Python and Github.

Setup your github account.

Setup your replit account and connect your github.

Join Replit I2P team with the link below.

Fork github.com/MrVanek/Interactive-Turtles and clone repository into replit.

Adding Moving Turtle

Assignment and Rubric

Create an interactive turtle application of your own design. This can be a game or other interactive program, but it must use at least two of the three types of turtle classes we have outlined (moving turtle, keyboard turtle, clickable turtle).

• 3 pts - Program works without errors

• 3pts - Program uses two classes of turtle

• 3pts - Program is interactive. Users can DO something with the program.

• 1pts - Program is cleaned up (unused imports have been deleted, for example)

How do I...

...make multiple things move?

...write text on the screen?

...stop movement with walls?

...make a ball move diagonally and bounce off multiple sides of the room?

... create a background image and have it change later?

...set up and check a timer

...add a start screen

...Save a High Score in a File?

... add points from different objects to a single score?

... get objects to check each other for different properties?

...find the x and y position of my mouse on the screen?

...create a custom shaped turtle?

I wanted to put our own spin on the Data lab from CollegeBoard for this project. Rather than just following the standard lab, we're going to analyze real-world video game sales data that will give you hands-on experience with classes, interfaces, and data processing in Java.

For this project, we'll be using a comprehensive dataset containing information about video games, including sales figures, critic ratings, user scores, and more. I've sourced this dataset from Kaggle: Video Game Sales and Ratings.

This project will give you practical experience with:

• Creating and using custom classes

• Working with interfaces

• Processing CSV data files

• Implementing search and analysis algorithms

• Visualizing data patterns

Activity 1: Getting Started

Our project requires two main Java classes:

• GameDataRow - Represents a single game record from our dataset

• GameDataManager - Handles loading and analyzing collections of game data

Let's start by looking at how to set up the GameDataRow class:

/**
 * The GameDataRow class represents a single video game from the dataset
 * and provides methods for analyzing game data including sales, ratings, and more.
 */
public class GameDataRow implements Comparable<GameDataRow> {
    // Instance variables will go here
    // Methods will go here
}

Understanding the Class Header and Interfaces

The class header public class GameDataRow implements Comparable<GameDataRow> has several important components:

1. public - This access modifier makes the class accessible from outside its package.

2. class GameDataRow - Defines a new class named GameDataRow.

3. implements Comparable<GameDataRow> - Indicates that this class implements the Comparable interface.

The Comparable Interface

The Comparable interface is part of the Java Collections Framework and enables objects of a class to be compared to each other. When a class implements Comparable, it must provide an implementation of the compareTo() method:

@Override
public int compareTo(GameDataRow other) {
    // if you want to implement Comparable, you'll need this sort of thing
    if (this.number > other.number) return -1;
    if (this.number < other.number) return 1;
    return 0;
}

The compareTo() method must return:

• A negative value if this object should be ordered before the other object

• Zero if both objects are equal

• A positive value if this object should be ordered after the other object

In our implementation, we're sorting games by global sales in descending order (highest sales first).

Other Common Interfaces in Java

While we're only using Comparable in this project, here are other common interfaces you might encounter:

• Serializable - Marks a class as capable of being serialized (converted to a byte stream).

public class MyClass implements Serializable { ... }

• Runnable - Used for classes whose instances will be executed by a thread.

  Copy

  public class MyTask implements Runnable {
      public void run() {
          // Code to be executed in a thread
      }
  }

• ActionListener - Used for handling action events, commonly in GUI applications.

  Copy

  public class ButtonHandler implements ActionListener {
      public void actionPerformed(ActionEvent e) {
          // Handle button click
      }
  }

• Iterable - Allows an object to be the target of the "for-each loop" statement.

  Copy

  public class MyCollection<T> implements Iterable<T> {
      public Iterator<T> iterator() {
          // Return an iterator
      }
  }

Properties and Encapsulation

Now, let's determine what properties our GameDataRow class needs. Our CSV file contains 17 columns of data about each game, and we want to represent each data point as instance variables in our class.

Looking at the structure of our CSV file, we need to create properties that match each column:

// Instance variables
private int index;
private String name;
private String platform;
private float yearOfRelease;
private String genre;
private String publisher;
private float naSales;
private float euSales;
private float jpSales;
private float otherSales;
private float globalSales;
private float criticScore;
private float criticCount;
private String userScore; // Note: String type, not float
private float userCount;
private String developer;
private String rating;

// Static variable to track number of games analyzed
private static int gamesAnalyzed = 0;

// Constants for regional sales references
public static final int NA_REGION = 0;
public static final int EU_REGION = 1;
public static final int JP_REGION = 2;
public static final int OTHER_REGION = 3;

Encapsulation Review

Remember that encapsulation is one of the four fundamental OOP concepts, along with inheritance, polymorphism, and abstraction. Encapsulation means bundling data and methods that operate on that data within a single unit (the class) and restricting direct access to some of the object's components.

Notice all our instance variables are marked as private. This is a key principle of encapsulation:

1. Private instance variables: By making our instance variables private, we prevent outside classes from directly accessing or modifying them.

2. Public accessor methods: We provide controlled access through getter methods (and sometimes setter methods).

3. Data validation: Through these methods, we can validate any changes to ensure they meet our requirements.

Good encapsulation ensures that the internal representation of an object can't be seen from outside the object's definition, which creates a "black box" effect.

Constructors

We need constructors to initialize our GameDataRow objects. A well-designed class should have multiple constructors to provide flexibility in object creation:

/**
 * Primary constructor for creating a new GameDataRow object with all fields
 */
public GameDataRow(int index, String name, String platform, float yearOfRelease, 
                   String genre, String publisher, float naSales, float euSales, 
                   float jpSales, float otherSales, float globalSales, 
                   float criticScore, float criticCount, String userScore, 
                   float userCount, String developer, String rating) {
    this.index = index;
    this.name = name;
    this.platform = platform;
    this.yearOfRelease = yearOfRelease;
    this.genre = genre;
    this.publisher = publisher;
    this.naSales = naSales;
    this.euSales = euSales;
    this.jpSales = jpSales;
    this.otherSales = otherSales;
    this.globalSales = globalSales;
    this.criticScore = criticScore;
    this.criticCount = criticCount;
    this.userScore = userScore;
    this.userCount = userCount;
    this.developer = developer;
    this.rating = rating;
    gamesAnalyzed++;
}

/**
 * Simplified constructor with essential fields only
 */
public GameDataRow(String name, String platform, float yearOfRelease, 
                   String genre, String publisher, float globalSales) {
    this.index = -1; // Default value for index
    this.name = name;
    this.platform = platform;
    this.yearOfRelease = yearOfRelease;
    this.genre = genre;
    this.publisher = publisher;
    this.naSales = 0.0f;
    this.euSales = 0.0f;
    this.jpSales = 0.0f;
    this.otherSales = 0.0f;
    this.globalSales = globalSales;
    this.criticScore = 0.0f;
    this.criticCount = 0.0f;
    this.userScore = "0.0";
    this.userCount = 0.0f;
    this.developer = "Unknown";
    this.rating = "Not Rated";
    gamesAnalyzed++;
}

/**
 * Copy constructor that creates a deep copy of another GameDataRow object
 */
public GameDataRow(GameDataRow other) {
    this.index = other.index;
    this.name = other.name;
    this.platform = other.platform;
    this.yearOfRelease = other.yearOfRelease;
    this.genre = other.genre;
    this.publisher = other.publisher;
    this.naSales = other.naSales;
    this.euSales = other.euSales;
    this.jpSales = other.jpSales;
    this.otherSales = other.otherSales;
    this.globalSales = other.globalSales;
    this.criticScore = other.criticScore;
    this.criticCount = other.criticCount;
    this.userScore = other.userScore;
    this.userCount = other.userCount;
    this.developer = other.developer;
    this.rating = other.rating;
    gamesAnalyzed++;
}

Notice I've included three constructors:

1. A primary constructor with all fields

2. A simplified constructor with only essential fields

3. A copy constructor to create a deep copy of an existing object

Accessor Methods (Getters)

Now we need accessor methods (getters) for all our instance variables. This is a perfect opportunity to use AI responsibly. Rather than typing out all these repetitive methods, you can ask Claude or an IDE's chatbot to generate them for you.

For example, you could say:

Please generate all the accessor methods for the GameDataRow class based on the instance variables.

This isn't plagiarism or cutting corners - it's using a tool to handle the tedious, repetitive aspects of coding so you can focus on the more challenging and creative aspects like designing algorithms and implementing the business logic.

Here's a snippet showing what a few of these accessor methods would look like:

// Accessor methods (getters)
public int getIndex() { return index; }
public String getName() { return name; }
public String getPlatform() { return platform; }
public float getYearOfRelease() { return yearOfRelease; }
public String getGenre() { return genre; }
public String getPublisher() { return publisher; }
// ... and so on for all instance variables

Test-Driven Development

Let's talk about Test-Driven Development (TDD) - a software development approach where you write tests before writing the actual implementation code. This practice has been widely adopted by professional developers because it leads to more reliable, maintainable code.

In TDD, the process follows three simple steps, often called "Red-Green-Refactor":

1. Write a test that fails (Red)

2. Write the minimal code to make the test pass (Green)

3. Improve the code without changing its behavior (Refactor)

For our project, I've prepared a complete main method that serves as a test suite. It will systematically test all the required functionality of your GameDataRow class and tell you exactly what's missing or not working correctly.

/**
 * Main method for testing the GameDataRow class
 */
public static void main(String[] args) {
    System.out.println("===== GAME DATA ROW TEST SUITE =====\n");
    int testsPassed = 0;
    int totalTests = 9;
    
    try {
        // Test 1: Basic constructor and accessors
        GameDataRow game1 = new GameDataRow(
            1, "Wii Sports", "Wii", 2006.0f, "Sports", "Nintendo", 
            41.49f, 29.02f, 3.77f, 8.46f, 82.74f, 
            76.0f, 51.0f, "8.0", 322.0f, "Nintendo", "E"
        );
        
        if (game1.getName().equals("Wii Sports") && 
            game1.getPlatform().equals("Wii") &&
            game1.getGlobalSales() == 82.74f) {
            System.out.println("✓ Test 1 Passed: Basic constructor and accessors working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 1 Failed: Basic constructor or accessors not working correctly");
        }
        
        // Test 2: Simplified constructor
        GameDataRow game2 = new GameDataRow("Super Mario Bros.", "NES", 1985.0f, 
                                           "Platform", "Nintendo", 40.24f);
        
        if (game2.getName().equals("Super Mario Bros.") && 
            game2.getGlobalSales() == 40.24f) {
            System.out.println("✓ Test 2 Passed: Simplified constructor working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 2 Failed: Simplified constructor not working correctly");
        }
        
        // Test 3: Copy constructor
        GameDataRow game3 = new GameDataRow(game1);
        
        if (game3.getName().equals(game1.getName()) && 
            game3.getGlobalSales() == game1.getGlobalSales() &&
            game3 != game1) {  // Different objects
            System.out.println("✓ Test 3 Passed: Copy constructor working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 3 Failed: Copy constructor not working correctly");
        }
        
        // Test 4: Static counter
        int expectedCount = 3;  // game1, game2, game3
        if (GameDataRow.getGamesAnalyzed() == expectedCount) {
            System.out.println("✓ Test 4 Passed: Static counter working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 4 Failed: Static counter expected " + 
                              expectedCount + " but got " + 
                              GameDataRow.getGamesAnalyzed());
        }
        
        // Test 5: Get regional sales
        if (Math.abs(game1.getRegionalSales(GameDataRow.NA_REGION) - 41.49f) < 0.01f) {
            System.out.println("✓ Test 5 Passed: Regional sales accessor working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 5 Failed: Regional sales accessor not working correctly");
        }
        
        // Test 6: Dominant region
        if (game1.getDominantRegion().equals("North America")) {
            System.out.println("✓ Test 6 Passed: Dominant region calculation working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 6 Failed: Dominant region expected 'North America' but got '" + 
                              game1.getDominantRegion() + "'");
        }
        
        // Test 7: Sales percentages
        float[] percentages = game1.getSalesPercentages();
        if (percentages.length == 4 && 
            Math.abs(percentages[0] - 50.14f) < 0.1f) {  // ~50.14% for NA
            System.out.println("✓ Test 7 Passed: Sales percentages calculation working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 7 Failed: Sales percentages not calculated correctly");
        }
        
        // Test 8: User score numeric conversion
        if (Math.abs(game1.getUserScoreNumeric() - 8.0f) < 0.01f) {
            System.out.println("✓ Test 8 Passed: User score numeric conversion working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 8 Failed: User score numeric conversion not working correctly");
        }
        
        // Test 9: compareTo implementation (formerly Test 10)
        if (game1.compareTo(game2) < 0 &&  // game1 has higher sales
            game2.compareTo(game1) > 0) {
            System.out.println("✓ Test 9 Passed: Comparable implementation working");
            testsPassed++;
        } else {
            System.out.println("✗ Test 9 Failed: Comparable implementation not working correctly");
        }
        
    } catch (Exception e) {
        System.out.println("\nTest failed with exception: " + e.getMessage());
        e.printStackTrace();
    }
    
    // Summary
    System.out.println("\n===== TEST SUMMARY =====");
    System.out.println("Passed: " + testsPassed + "/" + totalTests + " tests");
    
    if (testsPassed == totalTests) {
        System.out.println("🎉 Congratulations! All tests passed!");
    } else {
        System.out.println("❌ Some tests failed. Review the output above to see which tests failed.");
    }
}

Adding GameDataManager and Testing

Now that your GameDataRow class is complete, let's work with collections of games:

1. Copy the contents of GameDataManager.java file from this link: https://gist.github.com/dadiletta/2310e45953e3bcb8db3cf151c7c75d06

2. Download the video_games.csv file and place it in your project directory. The location should match the path in the GameDataManager.loadFromCSV() method call. https://www.kaggle.com/datasets/thedevastator/video-game-sales-and-ratings?resource=download

Activity 2: Building Methods

Now that we have our class structure and properties defined, it's time to add meaningful functionality to our GameDataRow class. To complete this class, you'll need to implement several methods that analyze game data in different ways.

I'm providing you with a few utility methods that handle some of the trickier aspects of parsing data from the CSV file, such as handling non-numeric user scores. Let's first look at these provided methods:

/**
 * Determines if the game has user reviews
 * @return true if user score and count are available
 */
public boolean hasUserReviews() {
    try {
        return Float.parseFloat(userScore) > 0 && userCount > 0;
    } catch (NumberFormatException e) {
        return false;
    }
}

/**
 * Convert user score from string to float, handling special values
 * @return user score as float or 0.0 if not available
 */
public float getUserScoreNumeric() {
    try {
        return Float.parseFloat(userScore);
    } catch (NumberFormatException e) {
        return 0.0f; // Return 0 for "tbd" or other non-numeric values
    }
}

/**
 * Returns a string representation of the game data
 */
@Override
public String toString() {
    StringBuilder sb = new StringBuilder();
    sb.append(name).append(" (").append(yearOfRelease).append(")");
    sb.append("\nPlatform: ").append(platform);
    sb.append("\nGenre: ").append(genre);
    sb.append("\nPublisher: ").append(publisher);
    sb.append("\nDeveloper: ").append(developer);
    sb.append("\nRating: ").append(rating);
    sb.append("\nGlobal Sales: ").append(globalSales).append(" million units");
    sb.append("\nDominant Region: ").append(getDominantRegion());
    
    if (hasCriticReviews()) {
        sb.append("\nCritic Score: ").append(criticScore).append("/100 (").append(criticCount).append(" critics)");
    }
    
    if (hasUserReviews()) {
        sb.append("\nUser Score: ").append(userScore).append("/10 (").append(userCount).append(" users)");
    }
    
    return sb.toString();
}

I'm giving you these methods because:

1. The hasUserReviews() and getUserScoreNumeric() methods handle data conversion and error checking that might be challenging

2. The toString() method is lengthy but straightforward, and implementing it wouldn't teach you much

Now, let's focus on the methods you need to implement:

Method 1: getAverageScore()

Return Type: float

This method calculates the average between critic and user scores. However, there's a challenge: critic scores are on a scale of 0-100, while user scores are on a scale of 0-10.

Requirements:

• Return a float representing the normalized average score on a scale of 0-10

• Normalize the critic score to a 0-10 scale by dividing by 10

• Handle cases where one or both scores are missing/invalid

• Return the appropriate average or individual score based on what's available

• Return 0.0f if no scores are available

Key Considerations:

• What constitutes an "available" score? (Hint: check for positive values)

• How do you handle the case where only one score type is available?

Hints:

You can paste this code into your method as a starting guide:

        // Convert critic score to scale of 10 like user score

        // fetch the user score using the built-in converter

        // check if any score is 0
            // if not, return the average of the two / 2.0f
            // else return the one with the number

Method 2: getSalesPercentages()

Return Type: float[]

This method calculates what percentage of the global sales comes from each region (North America, Europe, Japan, and Other).

Requirements:

• Return an array of float values representing percentages for each region

• The array should have 4 elements, one for each region

• Use the defined constants (NA_REGION, EU_REGION, etc.) for array indices

• Handle the case where globalSales is zero to avoid division by zero

Key Considerations:

• The formula for calculating percentage is: (regional sales / global sales) * 100

• If globalSales is zero, return an array of zeros to avoid division by zero

Method 3: hasSalesData()

Return Type: boolean

This method determines whether the game has any sales data available.

Requirements:

• Return true if any sales data (regional or global) is available

• Return false if all sales fields are zero

Key Considerations:

• Check all sales fields (naSales, euSales, jpSales, otherSales, globalSales)

• Use logical OR operators to efficiently check multiple conditions

Method 4: hasCriticReviews()

Return Type: boolean

This method determines whether the game has critic review data available.

Requirements:

• Return true if the game has both a critic score and a count of critics

• Return false if either piece of information is missing or zero

Key Considerations:

• Both criticScore and criticCount should be positive values

Method 5: getDominantRegion()

Return Type: String

This method determines which region has the highest sales for this game.

Requirements:

• Compare sales across all regions and find the highest

• Return a string representing that region ("North America", "Europe", "Japan", or "Other")

• Handle ties by choosing the first region encountered with the maximum value

Key Considerations:

• You'll need to track the maximum sales value and the corresponding region

• You can use a switch statement to convert from region index to region name (see example below)

Method 6: getRegionalSales()

Return Type: float

This method returns the sales figures for a specific region.

Requirements:

• Accept an int parameter representing the region (use the class constants)

• Return the sales figure (as a float) for the specified region

• Handle all four possible regions: NA_REGION, EU_REGION, JP_REGION, OTHER_REGION

Key Considerations:

• Use a switch statement to select the appropriate sales figure based on the region parameter

Switch Statement Example

A switch statement allows you to select one of many code blocks to be executed. Here's how you might implement the getRegionalSales method using a switch statement:

// Example of how to use a switch statement to return sales for a specific region
// Example switch statement to convert a day number to a day name
int dayNumber = 3;
String dayName;

switch(dayNumber) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}

The switch statement evaluates the regionIndex parameter and executes the code block that matches the case. The default case handles any values that don't match any specified cases.

Method 7: Implementation of Comparable

Return Type: int

You need to implement the compareTo method from the Comparable interface.

Requirements:

• Override the compareTo method to compare games based on global sales

• Higher sales should sort before lower sales (descending order)

• Return negative value if this game has higher sales than the other game

• Return positive value if this game has lower sales than the other game

• Return zero if both games have equal sales

Key Considerations:

• Remember that returning a negative value means "this" comes before "other" in the sorted order

Activity 3: Results

Let's add one final method to our GameDataRow class before moving on to working with collections of game data:

// Static method to get count of games analyzed
public static int getGamesAnalyzed() {
    return gamesAnalyzed;
}

Understanding Static Variables and Methods

This method introduces an important concept in Java: static members. Unlike instance variables and methods that belong to specific objects, static members belong to the class itself.

Here's what you need to know:

• Static variables (like our gamesAnalyzed counter) are shared across all instances of a class. There's only one copy in memory, regardless of how many objects you create.

• Static methods operate at the class level rather than the instance level. They can be called using the class name without creating an object: GameDataRow.getGamesAnalyzed().

• Cannot use this in static context: Since static methods don't operate on a specific instance, you cannot use the this keyword inside them. There's no "current object" to reference! If you try to use this in a static method, you'll get a compiler error.

• Access limitations: Static methods can only directly access other static members (variables or methods). They cannot directly access instance variables or methods without referencing a specific object.

In our case, we're using the static variable gamesAnalyzed to track how many game objects have been created throughout our program's execution. Each constructor increments this counter, and our static method lets us retrieve the current count.

Creating Your Own Analysis

Now it's time to put your skills to work! Modify the GameDataManager.java file to add your own custom analysis of the video game data.

Add at least one new method to the GameDataManager class that performs an interesting analysis. Here are some ideas:

1. Year Analysis: Which year had the highest average game quality? Most releases?

2. Developer Success Rate: For developers with multiple games, which ones have the highest average scores?

3. Cross-Platform Analysis: Which games appeared on the most platforms? Do multi-platform games sell better?

4. Sales vs. Ratings Correlation: Do higher-rated games generally sell better? Is there a difference between critic and user ratings?

5. Genre Evolution: How have the popularity of different genres changed over time?

Once you've added your analysis method(s), modify the main method to call your new method and display the results.

Example Custom Analysis Method

Here's what your custom analysis might look like (don't just copy this - create your own!):

/**
 * Analyze which platforms have the highest-rated games on average
 */
public void analyzePlatformQuality() {
    Map<String, Float> totalScores = new HashMap<String, Float>();
    Map<String, Integer> gameCounts = new HashMap<String, Integer>();
    
    // Collect data
    for (GameDataRow game : games) {
        if (game.hasCriticReviews()) {
            String platform = game.getPlatform();
            totalScores.put(platform, totalScores.getOrDefault(platform, 0.0f) + game.getCriticScore());
            gameCounts.put(platform, gameCounts.getOrDefault(platform, 0) + 1);
        }
    }
    
    // Calculate averages and find the best
    String bestPlatform = "";
    float bestScore = 0.0f;
    
    System.out.println("\n===== PLATFORM QUALITY ANALYSIS =====");
    System.out.println("Platform\tAvg. Critic Score\tGame Count");
    
    for (String platform : totalScores.keySet()) {
        int count = gameCounts.get(platform);
        if (count >= 10) { // Only consider platforms with enough games
            float avgScore = totalScores.get(platform) / count;
            System.out.printf("%s\t\t%.1f\t\t%d\n", platform, avgScore, count);
            
            if (avgScore > bestScore) {
                bestScore = avgScore;
                bestPlatform = platform;
            }
        }
    }
    
    System.out.println("\nBest-rated platform: " + bestPlatform + 
                       " with average score " + bestScore);
}

In the main method, you would add a call to your new analysis:

// Call your custom analysis
manager.analyzePlatformQuality();

Requirements for Your Custom Analysis

Your analysis should:

• Process data from multiple games

• Use loops and conditionals appropriately

• Output meaningful results

• Include comments explaining your approach

• Handle edge cases (like missing data)

Activity 4: Recursion

In this final activity, you'll explore recursion - a powerful programming technique where a method calls itself to solve a problem by breaking it down into smaller instances of the same problem.

Understanding Recursion

Recursion is a fundamental concept in computer science that provides elegant solutions to certain types of problems. A recursive method has two essential components:

1. Base case(s): The simplest scenario(s) that can be solved directly without further recursion

2. Recursive case(s): Where the method calls itself with a simpler version of the problem

Let's examine a simple example - calculating the factorial of a number:

/**
 * Calculates the factorial of n (n!)
 * @param n a non-negative integer
 * @return the factorial of n
 */
public static int factorial(int n) {
    // Base case
    if (n == 0 || n == 1) {
        return 1;
    }
    // Recursive case
    else {
        return n * factorial(n - 1);
    }
}

When calculating factorial(5):

1. The method first checks if n equals 0 or 1 (our base case) - it doesn't, so we move to the recursive case

2. It returns 5 * factorial(4)

3. Now it calculates factorial(4), which is 4 * factorial(3)

4. This continues until we reach factorial(1), which returns 1 (base case)

5. Then the recursion "unwinds": 1 * 2 * 3 * 4 * 5 = 120

Why Use Recursion?

Recursion offers several advantages:

1. Elegance: Recursive solutions can be concise and elegant for problems that would be complex to solve iteratively

2. Divide and conquer: Recursion naturally implements divide-and-conquer strategies, breaking down large data sets into smaller pieces

3. Tree traversal: For hierarchical data structures like trees, recursion provides a natural approach

4. Problem decomposition: Complex problems become simpler when broken into smaller, similar sub-problems

Implementing Recursion in Game Data Analysis

Looking at our GameDataManager class, several methods could benefit from a recursive approach. For example, finding games within a specific criteria could be implemented using a binary search algorithm rather than the current linear search.

Here's an example of how we could improve the findGamesByTitle method using a recursive binary search (assuming the games list is sorted by title):

/**
 * Find a game by title using recursive binary search
 * @param title the title to search for
 * @return the game if found, null otherwise
 */
public GameDataRow findGameByTitle(String title) {
    // Sort the games by title first (if not already sorted)
    Collections.sort(games, (g1, g2) -> g1.getName().compareTo(g2.getName()));
    
    // Call the recursive helper method
    return findGameByTitleHelper(title, 0, games.size() - 1);
}

/**
 * Recursive helper method for binary search
 */
private GameDataRow findGameByTitleHelper(String title, int low, int high) {
    // Base case: element not found
    if (low > high) {
        return null;
    }
    
    // Calculate middle index
    int mid = (low + high) / 2;
    
    // Get the game at the middle
    GameDataRow midGame = games.get(mid);
    
    // Compare the middle element
    int comparison = midGame.getName().compareTo(title);
    
    // If found, return it
    if (comparison == 0) {
        return midGame;
    }
    // If the middle element is greater, search the left half
    else if (comparison > 0) {
        return findGameByTitleHelper(title, low, mid - 1);
    }
    // Otherwise, search the right half
    else {
        return findGameByTitleHelper(title, mid + 1, high);
    }
}

The recursive binary search has a time complexity of O(log n), which is much more efficient than the O(n) time complexity of linear search, especially with large datasets.

Another example would be implementing a recursive merge sort:

/**
 * Sort games by a certain criteria using merge sort
 * @param criteria the sorting criteria (e.g., "sales", "score")
 */
public void sortGamesByMergeSort(String criteria) {
    games = mergeSort(games, criteria, 0, games.size() - 1);
}

/**
 * Recursive merge sort implementation
 */
private ArrayList<GameDataRow> mergeSort(ArrayList<GameDataRow> list, String criteria, int left, int right) {
    // Base case: list of size 1 or empty
    if (left >= right) {
        ArrayList<GameDataRow> result = new ArrayList<>();
        if (left == right) {
            result.add(list.get(left));
        }
        return result;
    }
    
    // Find the middle point
    int mid = (left + right) / 2;
    
    // Recursively sort both halves
    ArrayList<GameDataRow> leftHalf = mergeSort(list, criteria, left, mid);
    ArrayList<GameDataRow> rightHalf = mergeSort(list, criteria, mid + 1, right);
    
    // Merge the sorted halves
    return merge(leftHalf, rightHalf, criteria);
}

/**
 * Merge two sorted lists
 */
private ArrayList<GameDataRow> merge(ArrayList<GameDataRow> left, ArrayList<GameDataRow> right, String criteria) {
    ArrayList<GameDataRow> result = new ArrayList<>();
    int leftIndex = 0, rightIndex = 0;
    
    // Compare elements from both lists and add the smaller one to result
    while (leftIndex < left.size() && rightIndex < right.size()) {
        GameDataRow leftGame = left.get(leftIndex);
        GameDataRow rightGame = right.get(rightIndex);
        
        boolean addLeft = false;
        
        // Compare based on criteria
        if (criteria.equals("sales")) {
            addLeft = leftGame.getGlobalSales() >= rightGame.getGlobalSales();
        } else if (criteria.equals("score")) {
            addLeft = leftGame.getCriticScore() >= rightGame.getCriticScore();
        } else {  // Default to name
            addLeft = leftGame.getName().compareTo(rightGame.getName()) <= 0;
        }
        
        if (addLeft) {
            result.add(leftGame);
            leftIndex++;
        } else {
            result.add(rightGame);
            rightIndex++;
        }
    }
    
    // Add remaining elements
    while (leftIndex < left.size()) {
        result.add(left.get(leftIndex++));
    }
    
    while (rightIndex < right.size()) {
        result.add(right.get(rightIndex++));
    }
    
    return result;
}

Your Task

1. Choose one method from your GameDataRow or GameDataManager class that could benefit from a recursive approach

2. Reimplement it using recursion

3. Test your implementation and compare it to the original approach

4. Document your findings: Was the recursive approach more elegant? More efficient? What challenges did you face?

Alternatively, you can implement a new recursive method that performs a complex analysis that would be difficult to do iteratively. Here are some ideas:

• Find the most profitable franchise (games with similar names) recursively

• Implement a recursive algorithm to categorize games into hierarchical genres (e.g., "RPG > Action RPG")

• Create a recursive method to find "hidden gems" - games with high ratings but low sales

Example: Recursive Method for Maximum Critic Score

Here's an example of how you might implement a recursive method to find the game with the highest critic score within a list of games:

/**
 * Find the game with the highest critic score using recursion
 */
public GameDataRow findGameWithHighestCriticScore() {
    if (games.isEmpty()) {
        return null;
    }
    return findGameWithHighestCriticScoreHelper(0, games.size() - 1);
}

/**
 * Recursive helper to find the game with highest critic score
 */
private GameDataRow findGameWithHighestCriticScoreHelper(int start, int end) {
    // Base case: only one game
    if (start == end) {
        return games.get(start);
    }
    
    // Base case: two games
    if (start + 1 == end) {
        if (games.get(start).getCriticScore() >= games.get(end).getCriticScore()) {
            return games.get(start);
        } else {
            return games.get(end);
        }
    }
    
    // Find middle index
    int mid = (start + end) / 2;
    
    // Recursively find max in both halves
    GameDataRow leftMax = findGameWithHighestCriticScoreHelper(start, mid);
    GameDataRow rightMax = findGameWithHighestCriticScoreHelper(mid + 1, end);
    
    // Return the game with higher critic score
    if (leftMax.getCriticScore() >= rightMax.getCriticScore()) {
        return leftMax;
    } else {
        return rightMax;
    }
}

This method uses a divide-and-conquer approach, recursively finding the maximum in each half of the list and then comparing the results. While this specific example might not be more efficient than a simple loop, it demonstrates the recursive pattern that can be applied to more complex problems.

Remember, not all problems are best solved with recursion. Some considerations:

• Recursion can lead to stack overflow errors with very large inputs

• Recursive solutions sometimes have higher memory usage

• Some problems have simpler iterative solutions

This is so awesome!

The Internet is the largest idea exchange ever built or conceived. Learning HTML, the language of the web, gives you incredible power to represent yourself or your work, or your clients. Let's start first by gathering our resources.

Links and Resources

Required Software (install these)

• Visual Studio Code

• Google Drive

Required Practice (create accounts)

• Codecademy

• SoloLearn

Design Assets (bookmark these)

• Google Fonts

• AllTheFreeStock

• ThemeForest

Colors

• https://coolors.co

• https://colorhunt.co/

• Color wheel

• https://color.hailpixel.com

Extra Training for Extra Cool Kids

We won't study much JavaScript in this class but it's one of the best ways to take web design to the next level.

• Hard, smart: https://app.codesignal.com/ (select JavaScript)

• Fun: https://codecombat.com/ (select JavaScript)

Expectations

We will be learning programming concepts using GameMaker Studio 2's drag and drop interface as well as some simple GML code. All the concepts will be taught through the creation of games. Through PowerPoint instructions, you will be able to work at your own pace and return to concepts which might be confusing.

Mr. Vanek will be available to help if you have bugs that crop up in your programming and to clarify points in the tutorials.

In each unit, you will be responsible for completing an assignment which builds on the concepts you have learned. Feel free to flex your creative design muscles, especially in the assignment portion of the game. Adding extra features or finding new ways to accomplish them will help your game and your learning.

For the final project of the semester, you will be developing your own game. If you have good ideas for the form the game may take during the course of the semester, be sure to write them down.

Review the concepts:

• Crush all the Codingbat Problems

• Go over the AP Classroom problems

• Fill in any gaps in your skills

Get your speed up:

• https://www.varsitytutors.com/ap_computer_science_a-practice-tests

• http://www.danshuster.com/apcs/java_tests.htm

Watch Videos:

• https://www.youtube.com/playlist?list=PL-ZKvhIgD8x0Dgl2_rnNAv1lhJoRsIfLg

• https://www.youtube.com/playlist?list=PL_JS5ztwk2L9EhSQysP2tiQ_k5g_fAaji

Going Pro:

Learning Targets

• I can implement selection, insertion and merge sort algorithms.

• I can compare sorting algorithms' efficiency.

Algorithms

We've talked about algorithms before, most especially around the shuffling patterns we've used in the Elevens lab.

Efficiency

The bigger the group of data, the more important it is to be efficient. Searching on the web or in a database needs to be awfully fast. We measure the efficiency of a complex search or sort algorithm in Big O notation.

Searching

Let's knock out a quick algorithm first, searching. The O(n) way is just a straight traversal. But we could chop that down to a O(log n) with a binary search: