Hello, fellow learner !!!👋

April 27, 2025

It's been exactly 20 days since I started this blog journey, documenting my path toward growth in academics, programming, and personal development. Looking back at my earlier entries, I'm noticing something fascinating that I hadn't fully appreciated before: the unexpected ways my Python learning is enhancing my SAT preparation, and vice versa. Today, I want to explore this connection and share the insights I've gained.

The Surprising Connection Between Programming and Standardized Testing

When I first set out on these parallel tracks of SAT prep and Python learning, I saw them as completely separate endeavors. One was about cracking a standardized test, the other about mastering a programming language. But as I've progressed, I've noticed something remarkable: the mental models and problem-solving approaches I'm developing in one domain are strengthening my capabilities in the other.

Pattern Recognition: The Universal Skill

Pattern recognition stands at the core of both programming and SAT success. In Python, identifying patterns helps me write more efficient, elegant code. In SAT Reading, recognizing structural patterns in passages helps me locate information faster and predict answer choices more accurately.

Take yesterday's SAT practice session. I was working through a particularly challenging comparison passage about competing economic theories. In the past, I might have gotten lost in the details, but I found myself mentally "mapping" the passage structure almost like I would diagram a function in Python:

Main passage structure:
- Introduction (lines 1-12): Set up historical context
- Theory A explanation (lines 13-29): Key points, evidence
- Theory B explanation (lines 30-45): Key points, contrasting evidence
- Modern applications (lines 46-60): How both theories influence current thinking

This structural mapping approach—something I've been using when planning my Python projects—helped me navigate the passage more efficiently. I answered 9 out of 11 questions correctly in that section, up from my usual 7.

Debugging Mindset: From Code to Test Problems

In Python, debugging is a fundamental skill. When my code doesn't work as expected, I have to systematically trace through it, identify where things went wrong, and methodically fix the issues. This debugging mindset has transformed how I approach SAT Math problems.

Last week, I got a relatively simple algebra problem wrong on a practice test. Instead of just moving on with frustration (my old approach), I "debugged" my solution process:

I identified exactly where my calculation went wrong
I traced backward to find the conceptual misunderstanding
I rewrote my solution with the correct approach
I made a note of this pattern of error to watch for in future problems

This systematic approach to error analysis has dramatically improved my consistency in SAT Math. My careless errors have decreased by about 40% over the past two weeks.

Deepening My Python Knowledge Through Practical Applications

Object-Oriented Programming: Moving Beyond the Basics

My understanding of Object-Oriented Programming (OOP) in Python has leveled up significantly in the past week. I've moved beyond just creating simple classes to thinking about proper inheritance structures, encapsulation, and polymorphism. Here's a more sophisticated example from my current project:

class Student:
    def __init__(self, name, grade, student_id):
        self._name = name  # Using encapsulation with protected attributes
        self._grade = grade
        self._student_id = student_id
        self._courses = []

    @property  # Using property decorators for getter/setter methods
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        if isinstance(new_name, str) and len(new_name) > 0:
            self._name = new_name
        else:
            raise ValueError("Name must be a non-empty string")

    def enroll(self, course):
        if course not in self._courses:
            self._courses.append(course)
            return True
        return False

    def __str__(self):
        return f"Student: {self._name}, Grade: {self._grade}, ID: {self._student_id}"


class HighSchoolStudent(Student):
    def __init__(self, name, grade, student_id, graduation_year):
        super().__init__(name, grade, student_id)  # Using inheritance properly
        self._graduation_year = graduation_year
        self._sat_score = None

    def set_sat_score(self, score):
        if 400 <= score <= 1600:
            self._sat_score = score
        else:
            raise ValueError("SAT score must be between 400 and 1600")

    def get_college_readiness(self):
        if not self._sat_score:
            return "No SAT score recorded"

        if self._sat_score >= 1400:
            return "Very High"
        elif self._sat_score >= 1200:
            return "High"
        elif self._sat_score >= 1000:
            return "Moderate"
        else:
            return "Needs Improvement"

    def __str__(self):
        base_str = super().__str__()
        sat_info = f", SAT: {self._sat_score}" if self._sat_score else ""
        return f"{base_str}, Graduation Year: {self._graduation_year}{sat_info}"

This hierarchical structure feels so much more elegant and powerful than the flat, function-based programs I was writing just a month ago. I'm starting to see how OOP can model real-world relationships and create more maintainable, scalable code.

Data Analysis: Bringing My SAT Practice Data to Life

One project I'm particularly excited about combines my SAT preparation with Python data analysis. I've created a simple program that tracks my SAT practice test results and visualizes my progress over time:

import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime, timedelta

# Sample data tracking my SAT practice scores
dates = [datetime(2025, 3, 15), datetime(2025, 3, 22), 
         datetime(2025, 3, 29), datetime(2025, 4, 5),
         datetime(2025, 4, 12), datetime(2025, 4, 19), 
         datetime(2025, 4, 26)]

reading_scores = [32, 33, 35, 36, 38, 39, 41]  # Out of 52
writing_scores = [28, 31, 32, 35, 36, 37, 39]  # Out of 44
math_scores = [33, 35, 38, 39, 40, 42, 44]     # Out of 58

# Convert to scaled scores (approximation)
def scale_reading(raw):
    return int(200 + (raw/52) * 400)

def scale_writing(raw):
    return int(200 + (raw/44) * 400)

def scale_math(raw):
    return int(200 + (raw/58) * 600)

scaled_reading = [scale_reading(score) for score in reading_scores]
scaled_writing = [scale_writing(score) for score in writing_scores]
scaled_math = [scale_math(score) for score in math_scores]
total_scores = [r + w + m for r, w, m in zip(scaled_reading, 
                                           scaled_writing, 
                                           scaled_math)]

# Plotting my progress
plt.figure(figsize=(12, 8))
plt.plot(dates, scaled_reading, 'b-o', label='Reading')
plt.plot(dates, scaled_writing, 'g-o', label='Writing')
plt.plot(dates, scaled_math, 'r-o', label='Math')
plt.plot(dates, total_scores, 'k-o', label='Total Score')

plt.axhline(y=1600, color='gray', linestyle='--', alpha=0.5)
plt.axhline(y=1400, color='gray', linestyle='--', alpha=0.5)
plt.axhline(y=1200, color='gray', linestyle='--', alpha=0.5)

plt.title('My SAT Score Progression')
plt.xlabel('Practice Test Date')
plt.ylabel('Scaled Score')
plt.legend()
plt.grid(True, alpha=0.3)

# Predict future scores with simple linear regression
def predict_future_score(scores, periods_ahead=3):
    x = np.arange(len(scores))
    y = np.array(scores)

    # Simple linear regression
    m, b = np.polyfit(x, y, 1)

    # Predict future values
    future_x = np.arange(len(scores), len(scores) + periods_ahead)
    future_y = m * future_x + b

    return future_y.tolist()

# Predict scores for next 3 practice tests
future_dates = [dates[-1] + timedelta(days=(i+1)*7) for i in range(3)]
future_total = predict_future_score(total_scores)

plt.plot(future_dates, future_total, 'k--o', alpha=0.5)

# Annotate current and projected scores
plt.annotate(f'Current: {total_scores[-1]}', 
            xy=(dates[-1], total_scores[-1]),
            xytext=(10, -30), 
            textcoords='offset points',
            arrowprops=dict(arrowstyle='->'))

plt.annotate(f'Projected: {int(future_total[-1])}', 
            xy=(future_dates[-1], future_total[-1]),
            xytext=(10, 30), 
            textcoords='offset points',
            arrowprops=dict(arrowstyle='->'))

plt.savefig('sat_progress.png')
plt.show()

This visualization has been incredibly motivating. Seeing the upward trend in my scores makes all the hard work feel worthwhile, and the predictive element gives me something concrete to aim for. It's also strengthened my understanding of libraries like Matplotlib and NumPy.

SAT Preparation: Moving Beyond Memorization to Deep Understanding

Making Reading Comprehension Second Nature

The SAT Reading section used to intimidate me the most. The time pressure combined with dense passages on unfamiliar topics felt overwhelming. But I've developed a more strategic approach that's yielding better results:

Pre-reading reconnaissance: Before diving into the passage, I quickly scan the questions to identify what I need to look for.
Structural mapping: As mentioned earlier, I map the structure of each passage to create a mental "table of contents."
Active engagement: Instead of passive reading, I now mentally dialogue with the text, asking questions like "What's the author's main claim here?" or "How does this paragraph connect to the previous one?"
Evidence linking: For those paired questions (where one asks about a claim and the next asks for supporting evidence), I've gotten better at working backward from the evidence options to find the correct answer.

My reading comprehension improvements extend beyond the SAT. I'm finding myself better able to digest complex programming documentation and tutorials, retaining more information on the first pass.

Mathematical Thinking vs. Calculation

In SAT Math, I've shifted my approach from "how do I calculate this?" to "what is this problem really asking?" This change in perspective has helped me see shortcuts and elegant solutions I would have missed before.

For example, in a recent practice test, I encountered a problem about a quadratic function and its x-intercepts. Instead of working through the quadratic formula mechanically, I recognized that the problem was really testing my understanding of the relationship between roots and factors. This insight let me solve the problem in about 20 seconds instead of my usual minute-plus.

This deeper mathematical thinking carries over to my programming. When designing algorithms, I'm now more likely to step back and consider the mathematical properties of the problem before diving into code. This has led to more elegant, efficient solutions.

The Mental Game: Building Resilience and Focus

Timed Practice: Building Test-Taking Stamina

One of my biggest challenges with the SAT has been maintaining focus and performance throughout the entire test. To address this, I've been doing more full-length, timed practice tests rather than section-by-section practice.

The results have been revealing. I noticed that my performance would consistently dip in the third section, regardless of the content. This pointed to a stamina issue rather than a knowledge gap. To address this, I've been:

Simulating test conditions more rigorously (no phone, proper timing, single short break)
Using meditation techniques between sections to reset mentally
Working on physical stamina through proper sleep, nutrition, and exercise

These approaches have steadily flattened my performance curve across all sections.

Interestingly, I've noticed similar benefits when coding for longer periods. The focus techniques I've developed for SAT prep help me maintain "flow state" during programming sessions, allowing me to work through complex problems without losing momentum.

Embracing Mistakes as Learning Opportunities

Perhaps the most important mental shift I've made is in how I view mistakes. Previously, every wrong answer felt like a personal failure. Now, I see each mistake as a valuable data point—an opportunity to identify gaps in my understanding.

After each practice test, I maintain an "error log" where I analyze:

The exact question I got wrong
Why my approach led to an incorrect answer
The correct approach and why it works
Patterns in my errors (am I consistently missing certain question types?)

This systematic error analysis has transformed frustrating mistakes into productive learning experiences. The same approach has improved my programming—I now keep a similar log of bugs and debugging solutions, which has accelerated my learning considerably.

Looking Ahead: Integrating Skills for Exponential Growth

As I look to the coming months, I'm excited to find more ways to integrate my SAT preparation and programming skills. Some ideas I'm exploring:

Building a spaced repetition system in Python to help memorize SAT vocabulary and mathematical formulas
Creating a program that generates practice SAT-style questions based on patterns from official tests
Developing a personal dashboard that tracks all aspects of my preparation—practice scores, study hours, error patterns—to optimize my approach

These projects will not only improve my test preparation but also give me practical experience building useful applications in Python—a win-win for both goals.

Final Thoughts: The Power of Cross-Domain Learning

Twenty days into this journey, I'm convinced that the most powerful learning happens at the intersection of different domains. By pursuing excellence in both SAT preparation and Python programming simultaneously, I'm developing mental models and problem-solving approaches that transcend either field alone.

This cross-pollination of skills reminds me of the concept of "transfer learning" in machine learning—where a model trained on one task can apply its knowledge to perform better on a different but related task. My mind seems to work the same way, transferring insights and approaches between domains to accelerate my growth in both.

As I continue this journey, I'll be actively looking for more of these connections—finding the universal principles that underlie seemingly different fields. That's where the real magic happens.

Until next time,

-Saharsh Boggarapu

P.S. If you're on a similar journey of parallel learning, I'd love to hear about unexpected connections you've found between different domains you're studying. Drop a comment below!

Day 20: The Symbiotic Growth in Python and SAT Prep - Finding Patterns in Different Domains