I adjusted the code to complete the scatterplot.

First I defined the x and y axis and worked through the commands to draw
them. Then I changed the definitions so the program would draw the points.

This felt like the most complex code that we have written by a long shot.
There were a lot of challenges along the way, however when it came together it was
really satisfying. Overall, I felt like I understood the directions and I understood
why the answer was correct, but trying to configure the pieces to complete the code was
difficult. This could be from a number of factors, and is certainly not aided by the fact
that I have not had to do formal math of any kind for almost a decade. But like I said,
when it clicked, it clicked.

The top down thinking is something I am getting used to in terms of code. It reminds me a lot of scaffolding
in teaching. A task by itself can be daunting, but when it is broken down into parts it becomes manageable.
That being said, there are still places where I am struggling, but again, I am reminded of my students.
So many of them struggle all year to understand English concepts and I challenge them to embrace the discomfort
and have faith that the will be successful. Call it imposter syndome or learning curve, but I am enjoying the challenge and
trying to stick with it.

I was thinking about other data sets that require bounds and plotting. I think this would be an amazing
way to analyze and plot large amounts of data, like stuudent data maybe? I want to know more about what the inputting of data side of
the program as well.

scatterplot.py

@@ -34,9 +34,36 @@ def draw_scatterplot(data, size=5, color="black"):
     draw_points(data, color, size)
 
 def draw_axes(data):
+    draw_x_axis()
+    x_values = get_x_values(data)
+    xmin, xmax = bounds(x_values)
+    ticks = get_tick_values(xmin, xmax)
+    for tick in ticks: 
+        screen_x_position = scale(tick, xmin, xmax, 0, constants.PLOT_WIDTH)
+        draw_x_tick(screen_x_position, tick)
+    
+    draw_y_axis()
+    y_values = get_y_values(data)
+    ymin, ymax = bounds(y_values)
+    ticks = get_tick_values(ymin, ymax)
+    for tick in ticks: 
+        screen_y_position = scale(tick, ymin, ymax, 0, constants.PLOT_HEIGHT)
+        draw_y_tick(screen_y_position, tick)
+
     "Draws the scatter plot's axes."
 
 def draw_points(data, color, size):
+    x_values = get_x_values(data)
+    y_values = get_y_values(data)
+
+    xmin, xmax = bounds(x_values)
+    ymin, ymax = bounds(y_values)
+
+    for x, y in data:
+        scaled_x = scale(x, xmin, xmax, 0, constants.PLOT_WIDTH)
+        scaled_y = scale(y, ymin, ymax, 0, constants.PLOT_HEIGHT)
+
+        draw_point(scaled_x, scaled_y, color, size)
     "Draws the scatter plot's points."
 
 with no_delay():