Why You Should Google in English

While localization exists, English remains the lingua franca of the global technology sector. The overwhelming majority of technical documentation, research papers, community discussions (Stack Overflow, Cross Validated), and repository issues are authored in English.

Searching in a native language often introduces a translation layer that degrades query precision. Technical terms often lack accurate equivalents, or the translated terms yield results from a significantly smaller dataset.

Tip:

Regardless of linguistic proficiency, technical queries should be formulated in English to ensure access to the primary source of truth.

• Ineffective: خطای اتصال دیتابیس (Limited dataset, potential ambiguity)

• Effective: Database connection timeout error (Direct mapping to technical terminology)

Anatomy of a Perfect Search Query

Search engines utilize keyword-matching algorithms. Providing a query in conversational language introduces noise that dilutes the relevance of the results. An optimal query acts as a filter, prioritizing context.

A robust query structure typically consists of three components:

1. The Context: The language, framework, or library (e.g., Python, Pandas, React).

2. The Operation: What was being attempted (e.g., merge dataframes, render component).

3. The Symptom: The specific error or outcome (e.g., NaN values, infinite loop).

Google Search Operators You Need to Know

To refine search results, professionals should utilize boolean operators and search syntax modifiers.

Filter by Date (Don’t Copy Deprecated Code)

Technical ecosystems evolve rapidly. A solution that was standard practice three years ago may be deprecated or inefficient today. This is particularly true in Data Science (e.g., changes in Scikit-learn or TensorFlow APIs) and Frontend Development.

Methodology:

Utilize the search engine’s “Tools” feature to restrict results to the “Past Year”.

• This mitigates the risk of implementing legacy code.

• It ensures compatibility with current library versions.

How to Google Error Messages

A common pitfall is copying a raw stack trace directly into a search engine. Stack traces contain two types of information: generic error descriptions and local environment details.

Searching for specific information (like local file paths) will yield zero results because those paths do not exist on other machines.

Sanitization Process:

Before searching, the error message must be stripped of local context.

1. Raw Error: FileNotFoundError: [Errno 2] No such file or directory: '/Users/Yahya/Data/dataset.csv'

2. Sanitized Query: "FileNotFoundError" "No such file or directory" python

Beware of the “XY Problem”

The “XY Problem” happens when you try to solve problem X, come up with a solution Y, get stuck on Y, and then ask for help with Y.

This is counter-productive because Y might not even be the right way to solve X.

Example:

• The Goal (X): Remove rows with missing values from a dataset.

• The Attempt (Y): Write a for-loop to check and delete rows one by one.

• The Bad Search: “How to delete row in for loop python pandas.”

• The Good Search: “Pandas drop missing values.” (Which gives you dropna()).

Rule of Thumb:

Always ask yourself: “Am I searching for how to do what I think is the solution, or for the actual problem I’m trying to solve?”

Using AI Wisely (ChatGPT & Copilot)

AI tools like ChatGPT and GitHub Copilot are amazing for finding answers, but they aren’t perfect.

Good Use Cases:

• Explaining Syntax: “What does this regex do?” or “Explain this SQL query.”

• Comparing Concepts: “XGBoost vs. LightGBM trade-offs.”

The Danger:

AI models can “hallucinate”—confidently giving you code that looks right but is completely wrong or uses non-existent libraries. Always verify AI-generated code against official documentation.

Mastering the art of Googling changes how you code. It turns a frustrating error into a quick fix and a learning moment. By using these techniques, you don’t just solve the problem—you become a better developer.

Remember: The best developers don’t have all the answers memorized—they just know exactly how to find them.

The Discrete Problem: Linear Algebra and Regression

Let’s start with a classic scenario: we have a dataset comparing Marketing Budget () to Sales (). We want to find a function so that for our data, .

If we assume the relationship is linear, we are essentially trying to solve this system:

Feature Engineering and the Vandermonde Matrix

Often, a straight line doesn’t cut it. We might suspect a quadratic relationship: . This allows us to ask deeper questions:

1. What are the base sales? ()

2. How does the budget drive sales? ()

3. Does the budget lose effectiveness over time? ()

To solve this, we build the Vandermonde Matrix to hold our features:

Interpretation: If turns out negative, we have mathematically proven “Diminishing Returns.”

Visualizing the Bias-Variance Tradeoff

Choosing the right model complexity is tricky.

1. Underfitting (High Bias): If the model is too simple (Degree 1), we miss the pattern entirely.

2. Optimal Fit: A degree 2 polynomial hits the sweet spot, capturing the trend without memorizing noise.

3. Overfitting (High Variance): If the degree is too high (e.g., 15), the model connects the dots blindly, capturing noise instead of the signal.

Selecting the Best Model

To find the right degree (), we look at the Mean Squared Error (MSE). As complexity goes up, training error always drops, but test error (generalization) will eventually spike.

Beyond 2D: Multiple Regression

Real-world problems rarely have just one variable. Suppose we add Competitor’s Price (). Now, our model is a plane in 3D: .

Mathematically, nothing changes. We solve the same normal equations, just with a larger matrix .

The Continuous Problem: Signal Processing

Discrete data is standard in business, but fields like audio processing or ECG analysis deal with continuous signals. Here, we want to approximate a complex function with a polynomial for compression or speed.

The Trap: Standard Basis vs. Orthogonality

A beginner might try the standard basis (). Here is the problem: on the interval , and look very similar. They are highly correlated (multicollinearity). This confuses the model and makes coefficients unstable.

The fix is Orthogonality. We need features that are independent, meaning their inner product is zero:

Orthogonal bases (like Legendre Polynomials) give us:

1. Decoupling: We can calculate each coefficient separately.

2. Stability: Adding a higher-degree term doesn’t mess up the previous ones.

Final Simulation: Reconstructing a Complex Signal

To show the power of Continuous Least Squares, let’s reconstruct a complex signal (mixed sine, cosine, and exponentials) using Legendre polynomials. Because of orthogonality, we can compute the “contribution” of each degree independently.

This process highlights the elegance of the math: by projecting complex realities onto simpler orthogonal structures, we get both speed and clarity.

Course Info:

• Instructor: Dr. Najmeh Hosseini Monjezi

• University: University of Isfahan

The 3 Steps

To use the Scanner, follow these three steps.

import java.util.Scanner;

// This line prepares the scanner to read from the keyboard
Scanner input = new Scanner(System.in);

int age = input.nextInt();

Cheat Sheet: Which Command to Use?

Depending on the Data Type (variable) you want to fill, you must use a specific command.

💻 Full Code Example

Here is a complete program. It asks for a student’s number and age.

import java.util.Scanner; // Step 1

public class Main {
    public static void main(String[] args) {
    
        // Step 2: Setup the Scanner 
        // (Remember: Just copy this line for now!)
        Scanner input = new Scanner(System.in);

        // Step 3: Ask and Scan
        
        // 1. Ask for an Integer
        System.out.print("Enter your Student Number: ");
        int studentNumber = input.nextInt();

        // 2. Ask for an Integer
        System.out.print("Enter your age: ");
        int age = input.nextInt();

        // Print the results back to see if it worked
        System.out.println("--- Result ---");
        System.out.println("Student Number: " + studentNumber);
        System.out.println("Age: " + age);
    }
}

Summary

1. Import the tool at the top: import java.util.Scanner;
2. Setup the tool inside main: Scanner input = new Scanner(System.in);
3. Scan the specific type you need: nextInt() or nextDouble().

Happy Coding! 🚀