DEV Community: Pp

Why if Is Not Enough: Understanding try/except in Python

Pp — Sat, 20 Dec 2025 11:29:31 +0000

While I was writing a tip calculator in Python, you can check my GitHub for the full code, I realized that even though I used an if condition, errors were still happening.

The reason is that the if condition runs after the type conversion, but the error happens during the conversion itself.

def get_bill_amount(prompt: str) -> float:
    while True:
    value = input(prompt).strip()
    try:
        amount = float(value)
        if amount > 0:
            return amount
        print("Amount must be greater than 0.")
    except ValueError:
        print("Please enter a valid number.")

Expected user input: a number greater than 0
Type mismatch: when the user enters a string like abc
Error: the program crashes with ValueError: could not convert string to float

The key point is that float(value) is a risky operation. If the conversion fails, Python throws an error before the if condition is even checked.

Using value.isdigit() may look safe, but it fails for valid inputs like 12.5, -3, or even 10 with spaces. This is why try/except exists.

Rule of thumb:

if → checks logic (rules, range, conditions)
try/except → catches crashes (invalid operations like type conversion)

Always use if to validate rules, and try/except to protect your program from crashing.

How I Bought a Domain Name and Launched My Website on AWS

Pp — Sun, 14 Dec 2025 14:40:31 +0000

This blog documents how I bought a custom domain and launched my personal website on AWS using S3, Route 53, CloudFront, and SSL. I created this website mainly to learn backend and AWS by doing, not just for writing blogs.

Buying a Domain Name on Namecheap

I went to Namecheap.com and searched for a domain name using its built-in search bar.

I searched for parthiban.dev, and it was available, so I added it to the cart.

Namecheap showed optional add-ons such as SSL, business cards, VPN, and hosting plans. I skipped all of them. AWS provides free SSL certificates, and the other options were not required for a simple website setup.

I also skipped additional add-ons like business email, social media boosting, WordPress hosting, web hosting, and premium DNS.

Checkout

On the checkout page, I enabled domain privacy and disabled the auto-renew option. If you have a promo code, you can enter it in the promo code field.

Then I clicked Confirm Order.

Next, I created a Namecheap account and entered my credit card / UPI details to complete the payment. After the payment was successful, I received a confirmation email.

Finally, I accessed the Namecheap dashboard, where I could check my domain’s expiry date and verify my contact details.

Creating an AWS Account

I created an AWS account using the free-tier plan (valid for six months).

When you first sign up, AWS logs you in as the root user, which has full control over billing and account-level settings.

Since AWS recommends avoiding the root user for daily tasks, I created an IAM user account and attached the necessary permissions.

The root account is used only for billing and account administration.
The IAM user is used for daily operations such as uploading website files, managing services, and deployments.

After creating the IAM user, I logged in using that account to manage all website-related tasks.

Creating an S3 Bucket to Store Website Files

From the AWS Management Console, I navigated to:

Console Home → All Services → S3 (under Storage)

Then I clicked Create bucket.

What is a bucket?

A bucket is a container that holds data in Amazon S3.

What is Amazon S3?

Amazon S3 is a cloud storage service where you can safely store files like photos, videos, code, or website data and access them anytime over the internet.

Bucket configuration

Bucket type: General purpose
Bucket name: A unique name (I used my domain name)
AWS Region: The console usually defaults to us-east-1
- This does not lock your account to that region
- You can switch regions anytime from the top-right dropdown
Object ownership: ACLs disabled
Block all public access: Unchecked
Versioning: Off (optional)
Encryption: Enabled (default)
Tags: Optional

After reviewing the settings, the bucket was created.

I clicked the bucket to view its Properties, Permissions, and other details.

Enabling Static Website Hosting

I opened the Properties tab of the bucket and scrolled to the bottom to find Static website hosting.

I edited the settings and:

Enabled static website hosting
Selected Host a static website
Set index document to index.html
Set error document to error.html

Then I saved the changes.

Uploading Website Files

Next, I opened the Objects tab and clicked Upload.

I uploaded all the HTML, CSS, and image files of my static website that were stored on my desktop.

Making the Website Public Using a Bucket Policy

After uploading the files, I created a bucket policy.

Why is a bucket policy important?

A bucket policy defines rules that decide who can access the files inside an S3 bucket.

For public website hosting, users on the internet must be able to read the files.

Bucket Policy for `parthiban.dev`

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicRead",
      "Effect": "Allow",
      "Principal": "*",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::parthiban.dev/*"
    }
  ]
}

This policy allows anyone to read the website files, which is required for public access.

I saved the changes.

Connecting the Domain Using Route 53

I opened Services, searched for Route 53, and clicked Hosted zones.

Route 53 does not host the website itself — S3 does that. Route 53 manages DNS records for the domain.

I created a public hosted zone using my domain name. This automatically generated DNS details such as name servers and TTL values.

Next, I went to the Namecheap dashboard, opened Domain List, clicked Manage, and under Name servers, I selected Custom DNS.

I pasted the name servers copied from Route 53 and saved the changes.

DNS propagation can take up to 48 hours.

Creating DNS Records for the S3 Website

In the hosted zone, I clicked Create record.

Record type: A — Routes traffic to an IPv4 address
Alias: Enabled
Routing target: Alias to S3 website endpoint
Region: Asia Pacific (Mumbai)

This displayed the S3 website endpoint, such as:

s3-website.ap-south-1.amazonaws.com

I created the record and tested the domain. The website did not load immediately, so I waited for DNS propagation.

Getting an SSL Certificate (HTTPS)

After waiting for two days, I realized that I had forgotten to get an SSL certificate.

AWS provides free SSL certificates through AWS Certificate Manager (ACM).

I switched the region from Mumbai to US East (N. Virginia), which is required for CloudFront certificates.

I clicked Request a certificate, selected Request a public certificate, and entered my domain name (parthiban.dev).

I chose DNS validation and submitted the request.

The certificate status showed Pending validation.

In the Domain tab, I clicked Create records in Route 53, which automatically created the required DNS records. After validation, the certificate was issued.

Creating a CloudFront Distribution

Next, I created a CloudFront distribution.

I selected:

Origin type: Amazon S3
Origin: My S3 bucket
Endpoint: S3 website endpoint (not the REST endpoint)

I kept the cache and origin settings as default.

I did not enable Web Application Firewall (WAF).

On the TLS certificate page, I selected the SSL certificate associated with my domain.

In the General settings, I set the default root object to index.html.

After reviewing the configuration, I created the distribution and waited for it to deploy.

Pointing the Domain to CloudFront

Finally, I went back to the Route 53 hosted zone and edited the A record.

I changed the routing target to Alias to CloudFront distribution and selected my distribution.

After saving the changes and waiting for propagation:

My website was live. 🎉

Final Thoughts

This setup helped me understand how AWS services work together in a real-world scenario. I made mistakes, fixed them, and learned a lot in the process. This website will now serve as both my learning platform and my personal space on the internet.

Originally published on parthiban.dev

HTTP Made Simple: How Your Browser Talks to Servers

Pp — Sun, 05 Oct 2025 19:02:59 +0000

When you browse the web, your computer is constantly talking to other computers. The language they use is called HTTP — Hypertext Transfer Protocol.

HTTP is how your browser and a server exchange information. The “verbs” of this language are called HTTP methods. They tell the server what you want to do: read data, send data, delete something, or update it.

GET

Used to request information from the server.
Example: Loading your profile page.
You type a web address:

https://api.example.com/users

Your browser sends a GET request to the server. The server responds with data, a webpage, or an error.

POST

Used to send data to the server, usually to create something new.
Example: Signing up on a website.

How it works:
You see a form like this:

<form action="/signup" method="POST">
  <input name="name" placeholder="Your name" />
  <input name="email" placeholder="Your email" />
  <input name="password" type="password" placeholder="Your password" />
  <button type="submit">Sign Up</button>
</form>

When you fill it and click sign up, your browser sends:

POST /signup HTTP/1.1
Host: example.com
Content-Type: application/x-www-form-urlencoded

name=Parthiban&email=parthi@example.com&password=123456

Flask receives the request and extracts data. Flask connects to PostgreSQL and runs:

INSERT users...

PostgreSQL Insert the record and confirms.

Server Response:

HTTP/1.1 201 Created
{
  "message": "User created successfully!"
}

Your browser shows: “Welcome, Parthiban!”

PUT
Used to update or replace data entirely.
It’s idempotent. Doing it multiple times doesn’t change the result beyond the first time.

DELETE
Used to remove data.
Example: Clicking “Delete my account”:

PATCH
Used to make small changes to data without replacing it entirely.
Partially idempotent.

Why Not Access the Database Directly?
Direct access to the database is dangerous, it opens huge security risks:

Anyone could delete all data
View private information
Modify things they shouldn’t

That’s why we use servers as gatekeepers.

Servers as Gatekeepers
Think of the server (API) as a security guard. It checks every request:

Are you logged in?
Do you own this data?
Is it allowed?

If yes → server updates database.
If no → server sends “Unauthorized”.

Finally...
Frontend — What you see (HTML, CSS, JS in browser)
Backend — The brain (Node.js, Python, Java…)
Database — Memory storage (MySQL, MongoDB, PostgreSQL…)

Understanding SSL/TLS

Pp — Sun, 05 Oct 2025 05:49:50 +0000

SSL – Secure Sockets Layer
TLS – Transport Layer Security

What is SSL/TLS?

SSL is a protocol that encrypts data transmitted between computers.
TLS is the newer and more secure version of SSL.

SSL provides multiple layers of protection by encrypting data sent between the server and the end user.

When you see HTTPS in a website address, it means that some form of SSL/TLS encryption is being used.

The SSL Handshake

When you visit a secure website, your browser and the website’s server perform a handshake to establish a secure connection.

The browser sends a Client Hello! message to the server.

This includes details such as:

Browser information
Cipher settings
Operating system
Supported encryption algorithms

The server responds with a Server Hello! message.
It includes:

Server details
Selected encryption algorithm
Digital SSL certificate containing:
- Domain name
- Certificate Authority (CA)
- Public key (used for encryption)

The browser checks if the server’s SSL certificate is valid and issued by a trusted Certificate Authority (CA).

Certificate Authority (CA) — The organization that signs or vouches for an SSL certificate’s authenticity.

Session Key Exchange

If the certificate is valid:
The browser generates a random session key.
It encrypts this session key using the server’s public key (from the SSL certificate).
The encrypted session key is sent to the server.
The server decrypts it using its private key.

Then:
The server sends a “Finished” message to the browser.
The browser replies with its own “Finished” message — confirming the handshake.

Secure Connection Established

If both sides verify the messages successfully, a secure connection is established.
From this point on, all communication between your browser and the server is encrypted using the shared session key.

Final Thoughts

SSL/TLS protects your personal data, passwords, and payments from being intercepted.
It’s the reason why you can safely browse, shop, and communicate online every day.

Whenever you see the 🔒 lock icon next to a website, that’s SSL/TLS at work!

Symmetric/Asymmetric Encryption

Pp — Fri, 03 Oct 2025 07:03:48 +0000

Symmetric Encryption

One key is used for both encryption and decryption.

Example: Person A encrypts a document with a shared secret key/passphrase. Person B needs the same key to decrypt it.

Problem: The challenge is how to share the secret key securely.

If A emails the passphrase to B, anyone intercepting that email can also decrypt the document.

This is called the key distribution problem.

Secure key sharing methods:
Use a secure channel (e.g., face-to-face, phone call, or secure messenger like Signal).

Or, better: use asymmetric encryption to send the key securely.

Asymmetric Encryption

Two keys are used: a public key and a private key.

Keys come in pairs and are mathematically linked:

Public key: shared openly, used for encryption.
Private key: kept secret, used for decryption.

Person B shares their public key with Person A.
Person A encrypts the document with B’s public key.
Only B’s private key can decrypt it.

Advantage: No need to send secret keys via insecure channels. Even if someone intercepts the public key, they cannot figure out the private key.

How They Work Together

In practice:
Asymmetric encryption is often used to securely share a symmetric key.

Then, symmetric encryption (which is faster) is used to encrypt the actual large file or communication.

This is exactly how TLS/SSL (HTTPS) works:
Your browser and the server exchange public keys.
They use asymmetric encryption to safely share a symmetric session key.
That symmetric key is then used for fast, secure communication.

How Does a Website Actually Load in Your Browser?

Pp — Thu, 02 Oct 2025 18:49:05 +0000

Ever wondered what happens behind the scenes when you type a web address and hit enter? At first glance, it feels instant, but a lot of steps happen in just a few milliseconds.

Websites and Servers

A website is nothing but a collection of files. HTML, CSS, JavaScript, and media, that instruct your browser on how to display the site.

These files live on a server. A server is a powerful computer connected to the internet 24/7. Hosting simply means storing these files on the server so anyone around the world can access them.

URLs and Protocols

https://abc.com

HTTPS → This is the protocol, the set of rules your browser and server use to communicate. Think of it as the language they speak. HTTPS is just a secure (encrypted) version of HTTP.

abc.com → This is the domain name.

Domains and IP Addresses

A domain name like abc.com is actually a human-friendly way to point to an IP address.

An IP address is a unique identifier that tells the browser exactly which server to connect to.

Every device on the internet (including your phone and laptop) has its own IP address.

Since humans find names easier to remember than numbers, we use domains instead of typing IPs directly.

DNS – The Internet’s Phonebook

This is where DNS (Domain Name System) comes in. DNS is like a phonebook that stores domain names and their corresponding IP addresses.

Here’s how your browser finds the IP for a domain:

Browser cache → First, it checks if it has the domain saved locally.

OS cache → If not found, it asks the operating system (Windows, Android, etc.).

DNS resolver (usually your ISP) → Still not found? The OS forwards the query to the DNS resolver.

Recursive lookup → If the resolver doesn’t have the answer cached, it starts asking other DNS servers until it finds the correct IP.

Establishing the Connection

Once the IP is found, your browser connects to the server. But before sending data, both sides need to “shake hands”.

This is called the TCP 3-way handshake, which ensures both devices are ready to talk to each other.

Requesting and Rendering the Page

After the handshake, the browser sends an HTTP GET request to ask the server for the webpage.

The server responds with the files.

The browser’s rendering engine interprets the code and displays the page on your screen.

Final Thoughts

The next time you click on a link, remember: behind that instant load is a fascinating chain of steps, from DNS lookups to handshakes, all working together to bring the internet to life.

Ordered vs Unordered Types in Python

Pp — Mon, 15 Sep 2025 06:55:18 +0000

Ordered types

list: keeps elements in the order you insert them. so index positions = order.
tuple: same as list but immutable. It preserves the order of elements because positions are fixed once created.
dict: since Python 3.7, dictionaries preserve insertion order. Internally it’s still a hash table, but it keeps a linked index array that remembers the order keys.

[ 10 ] → [ 20 ] → [ 30 ]
  0        1        2

Unordered types

set: implemented as a hash table with no extra mechanism to track insertion order. Elements go into “buckets” based on their hash
frozenset: same as set but immutable. Still based on hash table, so no order guarantee.

Bucket 0: 30
Bucket 1: 10
Bucket 2: 20

Add another element? Python might reorganize all buckets:

Bucket 0: 20
Bucket 1: 30
Bucket 2: 10
Bucket 3: 40

Run this multiple times:
list, tuple, dict → always in the same order.
set, frozenset → order may appear stable for small runs, but not guaranteed.

Keeping things ordered always requires extra mechanism on top of the raw storage.

Unordered (set) = just buckets (fast + light).
Ordered (dict/list/tuple) = buckets + extra tracking of positions (more memory, but predictable).

Python Basics: Mutable vs Immutable Explained (with Local Analogies)

Pp — Fri, 12 Sep 2025 14:21:07 +0000

When learning Python, I find some difficulty in understanding about mutable and immutable objects.
Let’s me break it down in ELI5 style.

Mutable Objects

What is mutable objects: Can be changed after creation. Updates happen in place, same memory reference.

Examples: list, dict, set

Analogy 1 – Blackboard
Like a blackboard in a our classroom: you can erase, rewrite, and modify the content. The board itself doesn’t change, only what’s written on it.

Board == List
Content in board == List items

Analogy 2 – Chicken gravy in a pot
In the pot, you can add water, salt, or more chicken (if you're hungry). It’s still more or less the same gravy, just modified.

Pot == Set
Chicken gravy == Set items

Immutable Objects

What is immutable objects: Cannot be changed once created. Any modification creates a new object in memory.

Examples: int, float, str, tuple, frozenset

Analogy 1 – Exam Question Paper
Once the exam question paper is printed, you can’t change it. If there’s a mistake, you need to print a new one (or provide grace marks).

Analogy 2 – Idli
Once steamed, an idli can’t be reshaped or unsalted. If you want a idli with less salt, you must make a new batch.

only immutable objects are hashable

Final takeaways

Understanding this helps you avoid bugs (like using mutable default arguments in functions).
Analogies are for fun. Peace.

python: printing, variables and data types

Pp — Wed, 10 Sep 2025 19:29:38 +0000

Today I learned some Python basics on how printing works, how variables works, and the different data types in python.

print()

printing strings and variables that stored strings
concatenating strings
formatted strings
escape sequence like \n, \t and raw strings to skip escape
print numbers and result of expressions like add, sub, multiply, divide, power, etc
printing lists and dicts
separator and end arguments
printing loops and range function
string multiplication
casting when combining strings and numbers
use case of print() in debugging
.format() method

variables

naming rules: letters or underscore, case-sensitive, no reserved keywords
assigning values, multiple assignments
unpacking sequence
dynamically assigning values
constant variables: uppercase, not truly immutable

Data types

numbers
string
boolean
none
List (mutable, ordered)
Tuple (immutable, ordered)
Dictionary (key-value pairs)
Set (unordered, unique)
Frozenset (immutable set)

print() has a lot more to it than just basic output (formatting, sep/end, debugging)

DEV Community: Pp

Why if Is Not Enough: Understanding try/except in Python

Rule of thumb:

How I Bought a Domain Name and Launched My Website on AWS

Buying a Domain Name on Namecheap

Checkout

Creating an AWS Account

Creating an S3 Bucket to Store Website Files

What is a bucket?

What is Amazon S3?

Bucket configuration

Enabling Static Website Hosting

Uploading Website Files

Making the Website Public Using a Bucket Policy

Why is a bucket policy important?

Bucket Policy for parthiban.dev

Connecting the Domain Using Route 53

Creating DNS Records for the S3 Website

Getting an SSL Certificate (HTTPS)

Creating a CloudFront Distribution

Pointing the Domain to CloudFront

Final Thoughts

HTTP Made Simple: How Your Browser Talks to Servers

GET

POST

Understanding SSL/TLS

What is SSL/TLS?

The SSL Handshake

Session Key Exchange

Secure Connection Established

Final Thoughts

Symmetric/Asymmetric Encryption

Symmetric Encryption

Asymmetric Encryption

How They Work Together

How Does a Website Actually Load in Your Browser?

Websites and Servers

URLs and Protocols

Domains and IP Addresses

DNS – The Internet’s Phonebook

Establishing the Connection

Requesting and Rendering the Page

Final Thoughts

Ordered vs Unordered Types in Python

Ordered types

Unordered types

Python Basics: Mutable vs Immutable Explained (with Local Analogies)

Mutable Objects

Immutable Objects

Final takeaways

python: printing, variables and data types

print()

variables

Data types

Bucket Policy for `parthiban.dev`