Forem: Faraz Choudhary

How to Create a Simple Webpage Using HTML – Step-by-Step Guide

Faraz Choudhary — Mon, 07 Apr 2025 10:29:54 +0000

Creating a simple webpage is one of the best ways to begin your journey in web development. If you are new to HTML and web design, don’t worry! This step-by-step guide will walk you through the entire process in plain and easy-to-understand language. Whether you're a student, hobbyist, or future developer, you'll learn how to build your very first HTML webpage from scratch.

What is HTML?

HTML stands for HyperText Markup Language. It is the standard language used to create webpages. HTML uses tags and elements to define the structure of a webpage. It helps browsers understand how to display content, such as text, images, links, and more.

For example:

<h1>Hello, World!</h1>

This simple line displays a big heading on a webpage.

Why Learn HTML?

Before we dive into building a page, here are a few reasons why learning HTML is important:

It’s the foundation of every website.
It’s easy to learn for beginners.
It works perfectly with CSS and JavaScript.
You don’t need any special software—just a text editor and a browser.

What You Need to Get Started

To create a simple HTML webpage, you only need:

A text editor (like Notepad, Notepad++, VS Code, or Sublime Text)
A web browser (like Google Chrome, Firefox, Edge, or Safari)

Basic Structure of an HTML Document

Every HTML document follows a basic structure. Here's what it looks like:

<!DOCTYPE html>
<html>
  <head>
    <title>My First Webpage</title>
  </head>
  <body>
    <h1>Welcome to My Website</h1>
    <p>This is a simple HTML webpage.</p>
  </body>
</html>

Let’s break it down:

<!DOCTYPE html>: Tells the browser that this is an HTML5 document.
<html>: The root element of the page.
<head>: Contains meta info like title, styles, and links.
<title>: Sets the title in the browser tab.
<body>: All visible content (text, images, etc.) goes here.

Step-by-Step: Create a Simple HTML Page

Step 1: Open Your Text Editor

Open Notepad (Windows) or any code editor of your choice.

Step 2: Write the Basic HTML Code

Copy and paste the following code:

<!DOCTYPE html>
<html>
  <head>
    <title>My Simple HTML Page</title>
  </head>
  <body>
    <h1>Hello World!</h1>
    <p>This is my first webpage using HTML.</p>
  </body>
</html>

Step 3: Save the File

Click File > Save As
Name your file: index.html
Choose "All Files" in the Save As Type dropdown
Click Save

Step 4: Open in Browser

Double-click on your saved file index.html. It will open in your browser and display your webpage!

Common HTML Tags and Their Use

Let’s add more content and learn useful tags:

1. Headings

HTML has 6 heading tags from <h1> to <h6>.

<h1>This is H1</h1>
<h2>This is H2</h2>

2. Paragraphs

Use <p> to write text paragraphs.

<p>This is a paragraph in HTML.</p>

3. Links

Use the <a> tag to add clickable links.

<a href="https://www.google.com">Visit Google</a>

4. Images

Use the <img> tag to add images.

<img src="image.jpg" alt="My Image" width="300">

5. Lists

Ordered List:

<ol>
  <li>First item</li>
  <li>Second item</li>
</ol>

Unordered List:

<ul>
  <li>Apple</li>
  <li>Banana</li>
</ul>

6. Line Break and Horizontal Line

<br> <!-- Line Break -->
<hr> <!-- Horizontal Line -->

Adding Style with CSS (Bonus)

To make your page look better, you can use CSS (Cascading Style Sheets).

Example:

<!DOCTYPE html>
<html>
  <head>
    <title>Styled Page</title>
    <style>
      body {
        background-color: #f2f2f2;
        font-family: Arial;
        text-align: center;
      }
      h1 {
        color: darkblue;
      }
      p {
        color: #333;
      }
    </style>
  </head>
  <body>
    <h1>Styled Webpage</h1>
    <p>This page has a background color and styled text.</p>
  </body>
</html>

Now your webpage will look more attractive!

Add an Image and a Button

Let’s add an image and a button below your text:

<img src="https://via.placeholder.com/300" alt="Sample Image">
<br><br>
<button onclick="alert('Thanks for clicking!')">Click Me</button>

Complete HTML Example – Simple Webpage

<!DOCTYPE html>
<html>
  <head>
    <title>My Simple Website</title>
    <style>
      body {
        background-color: #f4f4f4;
        font-family: Verdana;
        padding: 20px;
        text-align: center;
      }
      h1 {
        color: teal;
      }
      p {
        font-size: 18px;
      }
      img {
        border-radius: 10px;
        margin-top: 10px;
      }
      button {
        background-color: teal;
        color: white;
        padding: 10px 20px;
        border: none;
        border-radius: 8px;
        cursor: pointer;
        font-size: 16px;
      }
    </style>
  </head>
  <body>
    <h1>Welcome to My HTML Page</h1>
    <p>This is a beginner-friendly webpage created using only HTML and a bit of CSS.</p>
    <img src="https://via.placeholder.com/300" alt="Sample Image">
    <br><br>
    <button onclick="alert('Thanks for clicking!')">Click Me</button>
  </body>
</html>

Save it as index.html and open it in your browser. Voila! You just built your first styled webpage.

Tips for Practicing HTML

Try changing headings, colors, and fonts.
Add more images or text sections.
Explore other tags like <table>, <form>, <video>, etc.
View the source code of websites (Right-click > View Page Source) to learn more.

Common Mistakes to Avoid

Forgetting to close tags (</p>, </body>, etc.)
Using the wrong file extension (always save as .html)
Missing quotes in attribute values
Not nesting tags correctly

Learning Resources

Here are some helpful resources to continue learning HTML:

W3Schools HTML Tutorial

Mozilla Developer Network (MDN)

Codewithfaraz HTML CSS JS Tutorial

Conclusion

Now you know how to create a simple webpage using HTML! This is the very first step in web development. Once you’re comfortable with HTML, you can move on to CSS and JavaScript to create more interactive and beautiful websites.

Keep practicing, try building your personal bio page, and experiment with different tags. Web development is a skill that gets better with time and experience. Start small, stay consistent, and you’ll soon be making full websites!

How to Write Clean Code in Python - Best Practices Guide

Faraz Choudhary — Sat, 07 Sep 2024 05:17:56 +0000

When writing Python code, it's essential to make it clean and easy to read. Clean code means your code is well-organized, simple to understand, and easy to maintain. In this guide, we’ll share the best tips to help you write clean code in Python, whether you're a beginner or an experienced developer.

Why Clean Code Matters

Writing clean code is essential for many reasons:

Readability: Clean code is easy to read, which helps other developers understand your code quickly.
Maintainability: If your code is clean, it's easier to update, debug, and improve.
Collaboration: Clean code is essential for teamwork, especially when sharing code with others or working on large projects.
Error Prevention: When your code is clean and organized, you're less likely to introduce bugs. Now, let’s explore some best practices that will help you write cleaner code in Python.

1. Use Meaningful Variable and Function Names

One of the easiest ways to improve code readability is by using clear and meaningful names for variables and functions. Avoid single-letter or cryptic names like x, y, or foo.

Example:

# Bad example
def calc(x, y):
    return x + y

# Good example
def calculate_total_price(item_price, tax):
    return item_price + tax

In the second example, it's easy to understand what the function does just by looking at the function name and variable names.

2. Follow PEP 8 Style Guide

PEP 8 is Python's official style guide, providing conventions for writing clean and readable code. Some key PEP 8 recommendations include:

Indentation: Use 4 spaces per indentation level.
Line Length: Keep lines shorter than 79 characters.
Spacing: Use spaces around operators and after commas.
Comments: Add comments to explain complex parts of the code. Following PEP 8 ensures that your code adheres to Python’s community standards.

Example:

# PEP 8 Example
def calculate_discounted_price(price, discount):
    """Calculate the final price after applying the discount."""
    discounted_amount = price * (discount / 100)
    final_price = price - discounted_amount
    return final_price

3. Write Modular Code

Break your code into smaller, manageable functions. Each function should do one specific task, making it easier to read, test, and debug.

Example:

# Bad example
def process_order(customer, items):
    total_price = 0
    for item in items:
        total_price += item['price']
    if total_price > 100:
        discount = total_price * 0.1
        total_price -= discount
    # Send email
    print(f"Order confirmed for {customer['name']}")
    return total_price

# Good example
def calculate_total_price(items):
    return sum(item['price'] for item in items)

def apply_discount(total_price):
    if total_price > 100:
        return total_price * 0.9
    return total_price

def send_confirmation_email(customer):
    print(f"Order confirmed for {customer['name']}")

def process_order(customer, items):
    total_price = calculate_total_price(items)
    total_price = apply_discount(total_price)
    send_confirmation_email(customer)
    return total_price

In the improved example, the code is split into smaller functions, making it easier to understand and maintain.

4. Use List Comprehensions for Simplicity

List comprehensions in Python provide a concise way to create lists. Using them can make your code cleaner and more readable.

Example:

# Without list comprehension
squares = []
for x in range(10):
    squares.append(x ** 2)

# With list comprehension
squares = [x ** 2 for x in range(10)]

The second example is shorter and easier to read.

5. Avoid Hardcoding Values

Avoid hardcoding values directly in your code. Instead, use constants or configuration files. This makes your code more flexible and easier to update.

Example:

# Bad example
def calculate_discount(price):
    return price * 0.1  # Discount is hardcoded

# Good example
DISCOUNT_RATE = 0.1

def calculate_discount(price):
    return price * DISCOUNT_RATE

In the second example, the discount rate is stored in a constant, making it easier to change if needed.

6. Add Comments and Docstrings

While clean code should be self-explanatory, adding comments and docstrings can help explain the purpose of complex functions or algorithms.

Comments: Explain why a particular approach is used.
Docstrings: Describe what a function does and its parameters. Example:

def find_largest_number(numbers):
    """
    Find the largest number in a list.

    Args:
    numbers (list): A list of numbers.

    Returns:
    int: The largest number.
    """
    return max(numbers)

The docstring helps other developers understand how to use the function without needing to read the entire code.

7. Keep Your Code DRY (Don’t Repeat Yourself)

Avoid duplicating code. If you notice repeating patterns, try to refactor your code to reuse functions or classes. This will make your code more maintainable and reduce the chances of errors.

Example:

# Bad example
def get_full_name1(first_name, last_name):
    return first_name + " " + last_name

def get_full_name2(first_name, last_name):
    return first_name + " " + last_name

# Good example
def get_full_name(first_name, last_name):
    return first_name + " " + last_name

8. Handle Errors Gracefully

Always handle exceptions using try and except blocks to prevent your program from crashing. You should also provide informative error messages to make debugging easier.

Example:

# Bad example
def divide_numbers(a, b):
    return a / b

# Good example
def divide_numbers(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "Error: Cannot divide by zero"

The second example prevents a crash and provides a helpful error message.

9. Use F-strings for Formatting

Python 3.6 introduced f-strings, a simple and readable way to format strings. They are much cleaner than older string formatting methods.

Example:

# Old way
name = "Alice"
greeting = "Hello, %s!" % name

# With f-strings
greeting = f"Hello, {name}!"

F-strings make your code easier to read and maintain.

10. Use Meaningful Imports

Only import the necessary modules and functions. Avoid wildcard imports like from module import * as they can clutter the namespace and make it harder to track dependencies.

Example:

# Bad example
from math import *

# Good example
from math import sqrt, pi

Conclusion

Writing clean code in Python is a valuable skill that helps you create readable, maintainable, and bug-free software. By following the best practices outlined in this guide—using meaningful names, following PEP 8, keeping your code modular, and handling errors gracefully—you can significantly improve your coding style.

Focus on readability, simplicity, and consistency, and you'll be well on your way to writing clean, professional Python code.