DEV Community: Ayaz

Why Every Developer Should Learn to Write (And Most Never Do)

Ayaz — Sat, 21 Mar 2026 19:02:00 +0000

I've met developers who can architect entire systems in their head, debug production issues at 2am, and write code that reads like poetry. But ask them to explain what they built in a Slack message, and suddenly it's three paragraphs of passive voice and jargon that nobody reads.

Writing is the skill most developers ignore. It's also the one that compounds the hardest.

The Myth That Code Speaks for Itself

There's a belief in tech culture that if your code is good enough, you don't need to explain it. Clean code is self-documenting. The work speaks for itself.

This is mostly false — and believing it quietly limits your career.

Your code runs on a server. Your ideas need to travel through other people's heads — your manager, your team, a client, a user reading your documentation at midnight trying to figure out why their integration is broken. Code doesn't do that. Writing does.

The developers who get promoted, who build strong personal brands, who land consulting work, who attract interesting projects — they're almost always good communicators. Writing is how you make your thinking visible.

What "Writing" Actually Means for a Developer

I'm not talking about literary fiction. Developer writing looks like:

Documentation** that people actually read instead of skipping
Technical blog posts** that explain how you solved a hard problem
Pull request descriptions** that give reviewers real context
Slack messages** that get responses instead of being ignored
README files** that onboard new contributors in minutes, not hours

None of this requires being a "good writer" in the traditional sense. It requires being clear, structured, and respectful of the reader's time. Those are learnable skills.

The Career ROI of Writing is Insane

Let me be specific about what writing has done for developers I know and have read about:

A developer starts a technical blog. They write one post per week about what they're learning — nothing fancy, just honest walkthroughs. Six months later, that blog is getting 10,000 monthly visitors. Recruiters find them. They get inbound job offers instead of cold-applying. One post lands them a consulting contract worth more than their monthly salary.

This is not a fantasy. This is what happens when you consistently put your thinking in public.

Writing scales in a way that code rarely does. A good article keeps working for you years after you wrote it. A well-written README gets your open-source project starred and used. A clear technical post gets shared in newsletters, Discord servers, and Slack groups you've never heard of.

Your code sits in a repository. Your writing travels.

Why Most Developers Never Bother

The honest reason most developers avoid writing is the same reason people avoid anything uncomfortable: it exposes you.

Writing forces you to commit to an idea. You can't hide behind abstraction the way you can in code. When you write "here's how I think about X," someone can read it and disagree. That feels risky.

But here's what I've noticed: the fear of being wrong publicly is much worse than actually being wrong publicly. A post with a mistake gets a comment pointing it out. You fix it. You learn. The internet moves on. Meanwhile, you've now written something that thousands of people found useful enough to read.

The other reason is that writing feels like it takes time away from coding. And in the short term, it does. But consider what you're building: a body of work that represents you, teaches others, and keeps attracting opportunities long after you've moved on to the next thing.

The Compound Effect of Writing Consistently

Writing is a skill that compounds. The first five posts you write are painful. They take forever, they don't read well, and almost nobody sees them. This is normal and necessary.

By post twenty, something shifts. You have a voice. You know how to structure an explanation. You've stopped waiting for permission to have an opinion. And the small audience you've accumulated is now sharing your work for you.

Developers who write consistently for one year almost always look back and say it was one of the best professional decisions they made. Not because writing replaced coding — but because it amplified everything else they were doing.

How to Start Without Overthinking It

You don't need a personal website. You don't need a newsletter. You don't need to write perfectly.

Start with Dev.to or Hashnode — both are free, beginner-friendly, and have built-in audiences of developers. Write about something you figured out this week. It doesn't have to be groundbreaking. "How I fixed this frustrating bug" is a perfectly good first post.

Write the article you wish existed when you were struggling with a problem. That framing makes it easier because you're not performing — you're helping a version of yourself from three weeks ago.

One post. Publish it. See what happens.

The worst outcome is that nobody reads it. You still practiced writing, clarified your own thinking, and have something to link to when someone asks if you have samples of your work.

The best outcome? It changes the trajectory of your career.

The Real Competitive Advantage

There are millions of developers in the world. The number who write consistently and publicly is a tiny fraction of that. Which means if you write — even imperfectly, even occasionally — you're doing something most of your peers never will.

That's not a small edge. In a market where it's hard to stand out, clear thinking expressed in clear writing is one of the most durable advantages you can build.

Learn to code. Obviously. But also learn to write.

The two together are more powerful than either one alone.

If this resonated with you, share it with a developer friend who keeps saying they'll "start a blog someday." Someday doesn't show up until you start.

How to Scrape a Website with Python in 10 Minutes

Ayaz — Sat, 21 Mar 2026 18:59:49 +0000

Introduction

Web scraping is one of those skills that sounds complicated but is surprisingly easy to pick up in Python. In this tutorial, I'll show you how to scrape real data from a website in under 10 minutes using two popular libraries: Requests and BeautifulSoup.

By the end, you'll have a working scraper that pulls data from a webpage and saves it in a format you can actually use.

What is Web Scraping?

Web scraping is the process of automatically extracting data from websites. Instead of manually copying information, you write a script that does it for you — instantly, at scale.

Common use cases:

Collecting product prices for comparison
Gathering news headlines
Building datasets for research or machine learning
Monitoring job listings

What we'll Need

Python 3.7+
Basic Python knowledge (loops, lists, print statements)
Terminal / command prompt

Step 1: Install the Libraries

Open your terminal and install the two libraries we'll use:

pip install requests beautifulsoup4

Requests — fetches the HTML content of a webpage
BeautifulSoup — parses and navigates that HTML so you can extract what you need

Step 2: Fetch a Web Page

We'll use books.toscrape.com — a website built specifically for scraping practice. No legal issues, no rate limits.

Create a file called scraper.py:

import requests
from bs4 import BeautifulSoup

url = "http://books.toscrape.com/"
response = requests.get(url)

print(response.status_code)  # Should print 200
print(response.text[:500])   # First 500 characters of the HTML

Run it:

python scraper.py

If you see 200 printed, the request worked. You're now downloading an entire webpage with 2 lines of code.

Step 3: Parse the HTML with BeautifulSoup

Now let's make sense of that HTML:

import requests
from bs4 import BeautifulSoup

url = "http://books.toscrape.com/"
response = requests.get(url)

soup = BeautifulSoup(response.text, 'html.parser')
print(soup.title.text)  # Prints the page title

BeautifulSoup turns the raw HTML into a navigable object. Think of it as a map for the webpage.

Step 4: Find the Data we Want

Right-click any book title on books.toscrape.com and hit "Inspect" in your browser. You'll see book titles are inside <h3> tags wrapped in <article class="product_pod">.

Let's extract all book titles:

import requests
from bs4 import BeautifulSoup

url = "http://books.toscrape.com/"
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

books = soup.find_all('article', class_='product_pod')

for book in books:
    title = book.h3.a['title']
    print(title)

Run it and you'll see 20 book titles printed in your terminal. That's web scraping — done.

Step 5: Extract More Data (Price + Rating)

Let's also grab the price and star rating for each book:

import requests
from bs4 import BeautifulSoup

url = "http://books.toscrape.com/"
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

books = soup.find_all('article', class_='product_pod')

for book in books:
    title = book.h3.a['title']
    price = book.find('p', class_='price_color').text
    rating = book.p['class'][1]  # e.g. "Three", "Five"
    print(f"{title} | {price} | {rating} stars")

Output will look like:

A Light in the Attic | £51.77 | Three stars
Tipping the Velvet | £53.74 | One stars
Soumission | £50.10 | One stars
...

Step 6: Save the Data to a CSV File

Raw printed data isn't very useful. Let's save it to a CSV so you can open it in Excel or use it in another script:

import requests
from bs4 import BeautifulSoup
import csv

url = "http://books.toscrape.com/"
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')

books = soup.find_all('article', class_='product_pod')

with open('books.csv', 'w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    writer.writerow(['Title', 'Price', 'Rating'])  # Header row

    for book in books:
        title = book.h3.a['title']
        price = book.find('p', class_='price_color').text
        rating = book.p['class'][1]
        writer.writerow([title, price, rating])

print("Saved to books.csv!")

Open books.csv and you'll have a clean spreadsheet of all 20 books with titles, prices, and ratings.

Step 7: Scrape Multiple Pages

The site has 50 pages. Let's loop through them all:

import requests
from bs4 import BeautifulSoup
import csv

base_url = "http://books.toscrape.com/catalogue/page-{}.html"
all_books = []

for page_num in range(1, 51):  # Pages 1 to 50
    url = base_url.format(page_num)
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')
    books = soup.find_all('article', class_='product_pod')

    for book in books:
        title = book.h3.a['title']
        price = book.find('p', class_='price_color').text
        rating = book.p['class'][1]
        all_books.append([title, price, rating])

    print(f"Scraped page {page_num}/50")

with open('all_books.csv', 'w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    writer.writerow(['Title', 'Price', 'Rating'])
    writer.writerows(all_books)

print(f"Done! Saved {len(all_books)} books.")

This scrapes all 1,000 books from the website and saves them in one CSV file.

Important: Be Responsible When Scraping

Before scraping any real website, always:

Check the robots.txt — visit website.com/robots.txt to see what's allowed
Add delays between requests using time.sleep(1) to avoid overloading servers
Read the Terms of Service — some sites prohibit scraping
Never scrape personal data without consent

What we Built

Here's a summary of what you can now do:

Task	Code
Fetch a webpage	`requests.get(url)`
Parse HTML	`BeautifulSoup(html, 'html.parser')`
Find elements	`soup.find_all('tag', class_='name')`
Save to CSV	`csv.writer`
Scrape multiple pages	Loop with `range()`

How to Build a REST API with Python and Flask (Step-by-Step)

Ayaz — Sat, 21 Mar 2026 18:55:46 +0000

Introduction

If you've been writing Python for a while, you've probably heard the term "REST API" thrown around a lot. But building one yourself? That can feel intimidating.

In this tutorial, I'll walk you through building a fully functional REST API from scratch using Python and Flask — one of the simplest and most popular web frameworks in Python. By the end, you'll have a working API that can Create, Read, Update, and Delete (CRUD) data.

No databases needed for this one — we'll use in-memory data to keep things simple and focused.

What You'll Need

Python 3.7 or higher installed
Basic knowledge of Python (functions, dictionaries, lists)
A terminal / command prompt
A text editor (VS Code recommended)

Step 1: Set Up Your Project

First, create a new folder for your project and set up a virtual environment.

mkdir python-rest-api
cd python-rest-api
python -m venv venv

Activate the virtual environment:

On Mac/Linux:

source venv/bin/activate

On Windows:

venv\Scripts\activate

Now install Flask:

pip install flask

Step 2: Create Your First Flask App

Create a file called app.py in your project folder:

from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route('/')
def home():
    return jsonify({"message": "Welcome to my REST API!"})

if __name__ == '__main__':
    app.run(debug=True)

Run it:

python app.py

Open your browser and go to http://127.0.0.1:5000/. You should see:

{
  "message": "Welcome to my REST API!"
}

Congratulations — you just built your first API endpoint! 🎉

Step 3: Add Some Data

Let's create a simple in-memory "database" of books. Add this to app.py just below your imports:

books = [
    {"id": 1, "title": "The Pragmatic Programmer", "author": "Andy Hunt"},
    {"id": 2, "title": "Clean Code", "author": "Robert C. Martin"},
    {"id": 3, "title": "You Don't Know JS", "author": "Kyle Simpson"}
]

Step 4: Build the GET Endpoints (Read)

Now let's add endpoints to fetch books.

Get all books:

@app.route('/books', methods=['GET'])
def get_books():
    return jsonify(books)

Get a single book by ID:

@app.route('/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
    book = next((b for b in books if b['id'] == book_id), None)
    if book is None:
        return jsonify({"error": "Book not found"}), 404
    return jsonify(book)

Test it by visiting http://127.0.0.1:5000/books — you'll see all three books returned as JSON.

Step 5: Build the POST Endpoint (Create)

This lets users add a new book by sending data to the API.

@app.route('/books', methods=['POST'])
def add_book():
    data = request.get_json()

    if not data or 'title' not in data or 'author' not in data:
        return jsonify({"error": "Title and author are required"}), 400

    new_book = {
        "id": len(books) + 1,
        "title": data['title'],
        "author": data['author']
    }
    books.append(new_book)
    return jsonify(new_book), 201

To test this, use a tool like Postman or curl:

curl -X POST http://127.0.0.1:5000/books \
  -H "Content-Type: application/json" \
  -d '{"title": "Atomic Habits", "author": "James Clear"}'

Step 6: Build the PUT Endpoint (Update)

This updates an existing book:

@app.route('/books/<int:book_id>', methods=['PUT'])
def update_book(book_id):
    book = next((b for b in books if b['id'] == book_id), None)
    if book is None:
        return jsonify({"error": "Book not found"}), 404

    data = request.get_json()
    book['title'] = data.get('title', book['title'])
    book['author'] = data.get('author', book['author'])
    return jsonify(book)

Step 7: Build the DELETE Endpoint

This removes a book by ID:

@app.route('/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
    global books
    book = next((b for b in books if b['id'] == book_id), None)
    if book is None:
        return jsonify({"error": "Book not found"}), 404

    books = [b for b in books if b['id'] != book_id]
    return jsonify({"message": f"Book {book_id} deleted successfully"})

Step 8: We Complete app.py

Here's the full file with everything together:

from flask import Flask, jsonify, request

app = Flask(__name__)

books = [
    {"id": 1, "title": "The Pragmatic Programmer", "author": "Andy Hunt"},
    {"id": 2, "title": "Clean Code", "author": "Robert C. Martin"},
    {"id": 3, "title": "You Don't Know JS", "author": "Kyle Simpson"}
]

@app.route('/')
def home():
    return jsonify({"message": "Welcome to my REST API!"})

@app.route('/books', methods=['GET'])
def get_books():
    return jsonify(books)

@app.route('/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
    book = next((b for b in books if b['id'] == book_id), None)
    if book is None:
        return jsonify({"error": "Book not found"}), 404
    return jsonify(book)

@app.route('/books', methods=['POST'])
def add_book():
    data = request.get_json()
    if not data or 'title' not in data or 'author' not in data:
        return jsonify({"error": "Title and author are required"}), 400
    new_book = {
        "id": len(books) + 1,
        "title": data['title'],
        "author": data['author']
    }
    books.append(new_book)
    return jsonify(new_book), 201

@app.route('/books/<int:book_id>', methods=['PUT'])
def update_book(book_id):
    book = next((b for b in books if b['id'] == book_id), None)
    if book is None:
        return jsonify({"error": "Book not found"}), 404
    data = request.get_json()
    book['title'] = data.get('title', book['title'])
    book['author'] = data.get('author', book['author'])
    return jsonify(book)

@app.route('/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
    global books
    book = next((b for b in books if b['id'] == book_id), None)
    if book is None:
        return jsonify({"error": "Book not found"}), 404
    books = [b for b in books if b['id'] != book_id]
    return jsonify({"message": f"Book {book_id} deleted successfully"})

if __name__ == '__main__':
    app.run(debug=True)

What we Built

In this tutorial, we built a fully working REST API that supports all four CRUD operations:

Method	Endpoint	What it does
GET	`/books`	Get all books
GET	`/books/<id>`	Get one book
POST	`/books`	Add a new book
PUT	`/books/<id>`	Update a book
DELETE	`/books/<id>`	Delete a book