Selenium vs PyTorch Comparison for Beginners

# Selenium — the first test every beginner writes
# Open a browser, log in, verify the result.

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

driver = webdriver.Chrome()

try:
    driver.get("https://demo-app.example.com/login")

    # Fill in credentials — find by label, not brittle XPath
    driver.find_element(By.ID, "email").send_keys("user@example.com")
    driver.find_element(By.ID, "password").send_keys("correct-password")
    driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()

    # Wait for the dashboard to appear
    WebDriverWait(driver, 10).until(
        EC.visibility_of_element_located((By.CSS_SELECTOR, "[data-testid='dashboard']"))
    )

    assert "Dashboard" in driver.title
    print("Login test passed")

finally:
    driver.quit()

# What this proves:
# - You can drive a real browser programmatically
# - You use explicit waits, not time.sleep()
# - You find elements by stable selectors
# - You handle teardown (driver.quit)
# - You understand what "end-to-end" really means

# Selenium is about verifying behaviour — not about
# producing predictions. Different problem entirely.

# Selenium — Page Object pattern
# The shape every Selenium interview expects you to write.

from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class LoginPage:
    def __init__(self, driver):
        self.driver = driver
        self.email = (By.ID, "email")
        self.password = (By.ID, "password")
        self.submit = (By.CSS_SELECTOR, "button[type='submit']")

    def load(self):
        self.driver.get("https://demo-app.example.com/login")
        return self

    def login(self, email, password):
        self.driver.find_element(*self.email).send_keys(email)
        self.driver.find_element(*self.password).send_keys(password)
        self.driver.find_element(*self.submit).click()
        return self

    def wait_for_dashboard(self):
        WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located((By.CSS_SELECTOR, "[data-testid='dashboard']"))
        )
        return self

# Test code becomes readable and reusable
# — the goal of the Page Object pattern.

# What this proves:
# - You separate page structure from test logic
# - You encapsulate locators in one place
# - You return self for readable chaining
# - You know why brittle XPath is a maintenance trap

# Selenium careers reward clean structure as much as
# clever selectors — this is what separates juniors
# from senior SDETs.

# PyTorch — a simple neural network
# The first pattern every beginner writes.

import torch
import torch.nn as nn

class SimpleNet(nn.Module):
    def __init__(self, input_size=10, hidden=32, output=2):
        super().__init__()
        self.fc1 = nn.Linear(input_size, hidden)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden, output)

    def forward(self, x):
        x = self.fc1(x)
        x = self.relu(x)
        return self.fc2(x)

model = SimpleNet()
print(model)

# What this proves:
# - You understand nn.Module and why it exists
# - You know forward() is where the data flows
# - You can define a multi-layer network cleanly
# - You know why ReLU is used (non-linearity)

# In PyTorch, the model is a class. The training
# process is separate — that separation is what makes
# PyTorch flexible for research and production.

# PyTorch — training loop
# The pattern every PyTorch interview expects you to write.

import torch
import torch.nn as nn

# Assuming model, train_loader already defined
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0

    for X_batch, y_batch in train_loader:
        X_batch, y_batch = X_batch.to(device), y_batch.to(device)

        optimizer.zero_grad()
        outputs = model(X_batch)
        loss = criterion(outputs, y_batch)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f"Epoch {epoch + 1} — loss: {running_loss / len(train_loader):.4f}")

# What this proves:
# - You know the training loop order:
#   zero_grad → forward → loss → backward → step
# - You move tensors to the right device
# - You understand model.train() vs model.eval()
# - You track running loss properly

# The training loop is the heart of PyTorch work.
# If you can explain each line, you can read
# any PyTorch codebase.