← Back to all projects

LEARN RSS DEEP DIVE

Learn RSS: From Zero to Feed Master

Goal: Deeply understand the RSS ecosystem—from the XML specification and HTTP mechanics to building your own feed aggregators and publishers.

Why Learn RSS?

RSS (Really Simple Syndication) is a cornerstone of the open web. It’s a decentralized, anonymous, and chronological way to follow content you care about, free from algorithms and ads. While social media has overshadowed it, RSS still powers podcasting, news aggregation, and countless information workflows.

Understanding RSS is to understand a fundamental piece of internet infrastructure. After completing these projects, you will:

  • Read and understand the RSS and Atom XML formats fluently.
  • Know how RSS clients discover, fetch, and parse feeds.
  • Build tools to consume and display feed content.
  • Publish your own valid RSS feeds.
  • Create a full-featured, web-based RSS aggregator from scratch.

Core Concept Analysis

The RSS Ecosystem

┌────────────────────────┐      ┌────────────────────────┐      ┌────────────────────────┐
│      Your Website      │      │     Another Website    │      │     Podcast Host       │
│ (e.g., a blog)         │      │ (e.g., a news site)  │      │ (e.g., Libsyn)         │
└────────────────────────┘      └────────────────────────┘      └────────────────────────┘
           │                              │                              │
           │ Generates                    │ Generates                    │ Generates
           ▼                              ▼                              ▼
┌────────────────────────┐      ┌────────────────────────┐      ┌────────────────────────┐
│      rss_feed.xml      │      │      atom_feed.xml     │      │   podcast_feed.xml   │
└────────────────────────┘      └────────────────────────┘      └────────────────────────┘
           ▲                              ▲                              ▲
           │                              │                              │
           │ 1. Client polls via HTTP GET │                              │
           │                              │                              │
           └───────────────┬──────────────┴───────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                          YOUR RSS AGGREGATOR                            │
│                                                                         │
│  1. Fetch: Downloads the XML file.                                      │
│  2. Parse: Reads the XML and extracts items.                            │
│  3. Diff: Compares with stored items to find what's new.                │
│  4. Store: Saves new items to a database.                               │
│  5. Display: Shows the user a unified list of new content.              │
└─────────────────────────────────────────────────────────────────────────┘

Fundamental Concepts

  1. The Feed Format (XML): An RSS feed is just a text file formatted in a specific XML schema.
    • <rss>: The root element.
    • <channel>: Contains metadata about the feed (title, link, description).
    • <item>: Represents a single piece of content (a blog post, a news article, a podcast episode).
    • Key item tags: <title>, <link>, <description>, <pubDate>, and <guid>. The <guid> is a unique identifier crucial for tracking seen items.
  2. The “Behind the Scenes” Mechanics:
    • Publishing: A server simply makes an .xml file available at a public URL.
    • Discovery: A user finds the feed URL via a special <link> tag in the HTML of a webpage: <link rel="alternate" type="application/rss+xml" title="RSS" href="/feed.xml">.
    • Fetching: An RSS client (aggregator) periodically sends a standard HTTP GET request to the feed URL to download the XML file.
    • Parsing: The client reads the XML and converts it into a list of structured objects.
    • State Management: The client must keep track of the guid or link of every item it has ever seen. When it fetches the feed again, it can identify which items are new by looking for guids not in its database. This is the core logic of an aggregator.

Project List

The following 10 projects will take you from a simple script to a complete, modern RSS web application.

Project 1: Manual Feed Fetcher and Parser

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go, Node.js
  • Coolness Level: Level 2: Practical but Forgettable
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 1: Beginner
  • Knowledge Area: HTTP / Data Parsing
  • Software or Tool: HTTP Client (like Python’s requests)
  • Main Book: “Automate the Boring Stuff with Python, 2nd Edition” by Al Sweigart

What you’ll build: A command-line script that takes the URL of an RSS feed, downloads the raw XML, and prints the titles of the 5 most recent articles using basic string searches.

Why it teaches RSS: It forces you to look at the raw source of an RSS feed and understand its text-based structure before you rely on a fancy XML parser. You’ll see the <item>, <title>, and <link> tags in their natural habitat.

Core challenges you’ll face:

  • Making an HTTP GET request → maps to understanding how data is fetched from a URL
  • Handling the response → maps to getting the text content from the HTTP response
  • Parsing with string manipulation → maps to finding the content between <title> and </title> tags without a formal parser

Key Concepts:

  • HTTP GET Request: Chapter 12 of “Automate the Boring Stuff”.
  • RSS 2.0 Specification: Look at a real feed’s source (e.g., view-source:https://hnrss.org/frontpage).
  • String Searching: Basic Python string methods like split() and find().

Difficulty: Beginner Time estimate: A few hours Prerequisites: Basic Python or other scripting language.

Real world outcome: A script that produces simple console output like this:

$ python fetch.py https://hnrss.org/frontpage
Fetching feed...

1. Show HN: I made a visual study tool for math
2. The CIA's most highly-trained spies used a system of note-taking
3. Google Search Is Dying
4. A 1968 book accurately predicted the web
5. A Practical Guide to the `--config` option in Node.js

Implementation Hints:

  1. Use a library like requests in Python to get the feed URL.
  2. Get the response text: response.text.
  3. Don’t use an XML parser yet! The goal is to do it “manually”.
  4. Split the entire text by the <item> tag. This will give you a list of strings, where each string is one article.
  5. For each of those strings, find the first occurrence of <title> and </title>. The content between them is the title.
  6. Print out the titles you find.

Learning milestones:

  1. Feed XML is printed to console → You understand that a feed is just text served over HTTP.
  2. Article titles are extracted and printed → You understand the basic, repeating structure of an RSS feed.

Project 2: A Proper RSS Parser Library

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go, Rust, C
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Data Parsing / Library Design
  • Software or Tool: An XML parsing library (like Python’s xml.etree.ElementTree)
  • Main Book: “Fluent Python, 2nd Edition” by Luciano Ramalho (for data class design)

What you’ll build: A reusable Python module that takes raw XML text as input and returns a clean list of data objects (e.g., a list of Article structs/classes), with each object having .title, .link, .description, and .pubDate attributes.

Why it teaches RSS: It moves you from brittle string-matching to robust, structured data extraction. You’ll learn to navigate the XML tree (the “Document Object Model” or DOM) and handle variations and missing tags gracefully. This is the heart of any real RSS application.

Core challenges you’ll face:

  • Using an XML parsing library → maps to understanding how to find elements and their attributes in a DOM tree
  • Handling different namespaces → maps to dealing with feeds that include extensions, like the content:encoded tag
  • Designing a clean data structure → maps to creating a class or struct that represents a single <item> cleanly
  • Error handling → maps to what to do if a feed is malformed or a tag is missing

Key Concepts:

  • XML ElementTree: The official Python documentation for xml.etree.ElementTree.
  • XPath: A query language for selecting nodes in an XML document. Many libraries support it.
  • Data Classes: Python’s @dataclass is perfect for creating the Article structure.

Difficulty: Intermediate Time estimate: 1 day Prerequisites: Project 1, basic understanding of object-oriented programming or structs.

Real world outcome: A Python module you can import and use like this:

import rss_parser

xml_data = fetch_feed_xml("https://example.com/feed.xml")
articles = rss_parser.parse(xml_data)

for article in articles:
    print(f"Title: {article.title}")
    print(f"Published: {article.pubDate}")
    print("-" * 20)

Implementation Hints:

  1. Use xml.etree.ElementTree in Python. ET.fromstring(xml_text) gives you the root element.
  2. The root is the <rss> tag. You’ll want to find the <channel> child, and then loop through all of its <item> children.
  3. For each <item> element, use the .find('tagname') method to get the element for the title, link, etc. Then get its .text content.
  4. The pubDate will be a string. It’s a great “extra credit” step to parse this string into a proper datetime object.
  5. The guid is crucial for later projects. Make sure you parse it. It can be found in a <guid> tag.
  6. Create an Article dataclass to hold the extracted data for each item. Your parse function should return a List[Article].

Learning milestones:

  1. Parsing a simple feed works → You can navigate a simple XML DOM.
  2. Your parser handles feeds with different extensions (like Atom) → You understand namespaces and how to find tags within them.
  3. The module returns clean, typed objects → You have built a robust, reusable data parsing library.

Project 3: Build Your Own RSS Feed

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Shell Script, Go
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Content Management / File Generation
  • Software or Tool: XML, File I/O
  • Main Book: No book needed, refer to the RSS 2.0 Spec.

What you’ll build: A script that generates a valid RSS 2.0 feed for a collection of local markdown or text files. The script will create an rss.xml file that you could serve from a static web server.

Why it teaches RSS: It flips the perspective. You are now the publisher, not the consumer. This forces you to understand the RSS specification in detail: what tags are required, what are optional, and how to format them correctly so other people’s parsers can read your feed.

Core challenges you’ll face:

  • Generating valid XML → maps to creating the correct nested structure of <rss>, <channel>, and <item> tags
  • Populating required channel tags → maps to providing a title, link, and description for the feed itself
  • Creating a unique GUID for each item → maps to understanding the importance of a stable, unique identifier for each post
  • Formatting dates correctly → maps to producing a pubDate string that conforms to the RFC 822 standard

Key Concepts:

  • RSS 2.0 Specification: The definitive guide for what makes a valid feed.
  • RFC 822 Date Format: The required format for the <pubDate> tag (e.g., Sat, 07 Sep 2002 00:00:01 GMT).
  • XML Generation: Using a library to build XML is easier and safer than concatenating strings.

Difficulty: Intermediate Time estimate: 1 day Prerequisites: Basic scripting.

Real world outcome: A script that you can run in a directory of blog posts:

/my_blog/
├── post1.md
├── post2.md
└── generate_feed.py

Running python generate_feed.py will create a new rss.xml file in that directory. You can then open this file in a browser or validator to confirm it’s a valid RSS feed.

Implementation Hints:

  1. Your script will scan the current directory for .md or .txt files.
  2. For each file, it will extract a title (e.g., the first line) and content.
  3. You need to define the main <channel> properties: a title for your blog, a link to your (hypothetical) website, and a description.
  4. For each post file, you’ll generate an <item> block.
    • <title>: The post’s title.
    • <link>: A hypothetical link to the post on your website (e.g., https://myblog.com/post1.html).
    • <guid>: Use the link as the GUID. It’s simple and effective. isPermaLink="true".
    • <pubDate>: Use the file’s modification time, formatted correctly.
    • <description>: The first few sentences of the post.
  5. Use an XML library to build the document tree and then write it to rss.xml. This avoids errors with escaping special characters like & or <.

Learning milestones:

  1. An rss.xml file is generated → You understand the basic output of a feed publisher.
  2. The feed passes an online validator → You have correctly followed the RSS specification.
  3. Your feed can be successfully parsed by the tool you built in Project 2 → You have built both ends of the system and they are compatible.

Project 4: Simple Command-Line RSS Reader

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go, Rust
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: State Management / CLI App
  • Software or Tool: File I/O, SQLite (optional)
  • Main Book: “The Pragmatic Programmer” by Hunt & Thomas (for its advice on building tools)

What you’ll build: A command-line tool that reads a list of feed URLs from a feeds.txt file. When you run it, it fetches all the feeds and prints the titles of any articles it hasn’t shown you before.

Why it teaches RSS: This is your first real aggregator. It forces you to solve the most important “behind the scenes” problem: how to keep track of what’s new.

Core challenges you’ll face:

  • Reading a list of feeds → maps to basic file I/O to get the list of URLs to fetch
  • Managing state between runs → maps to deciding how to store the GUIDs of articles you’ve already seen
  • Comparing new items to seen items → maps to the core “diffing” logic of a feed reader
  • Persisting state → maps to saving the list of seen GUIDs to a file (e.g., seen_guids.txt or a simple SQLite database)

Key Concepts:

  • Statefulness: The concept of a program remembering information between executions.
  • Unique Identifiers: The critical role of the <guid> tag.
  • Data Persistence: Storing data on disk. A plain text file is fine to start; a database is better.

Difficulty: Intermediate Time estimate: 1 day Prerequisites: Project 2.

Real world outcome: The first time you run it, it shows all articles. The second time, it shows nothing (unless a new article was published).

# First run
$ python reader.py
(Showing 10 new articles from 'Feed 1')
- Article A
- Article B
(Showing 5 new articles from 'Feed 2')
- Article X
- Article Y

# Second run (a few minutes later)
$ python reader.py
(No new articles)

# Third run (an hour later, a new post was published)
$ python reader.py
(Showing 1 new article from 'Feed 1')
- Article C

Implementation Hints:

  1. Create a feeds.txt with one feed URL per line. Your script will read this file.
  2. Create a file to store seen GUIDs, e.g., seen.db. A plain text file with one GUID per line is the simplest start.
  3. When the script starts, load all seen GUIDs from seen.db into a Python set for fast lookups.
  4. For each feed in feeds.txt:
    • Fetch and parse it using your library from Project 2.
    • For each article item:
      • Check if its guid is in your set of seen GUIDs.
      • If it is NOT, print the article title (it’s new!) and add the guid to your set.
  5. After processing all feeds, write the entire updated set of GUIDs back to your seen.db file, overwriting it.

Learning milestones:

  1. The app remembers seen articles → You have successfully implemented state management.
  2. The app works with multiple feeds → You have created a true aggregator.
  3. Using a set for lookups is fast → You appreciate using the right data structure for the job.

Project 5: Feed Auto-Discovery

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go, Node.js
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 1. The “Resume Gold”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Web Scraping / HTML Parsing
  • Software or Tool: HTML Parsing Library (like BeautifulSoup)
  • Main Book: “Web Scraping with Python, 2nd Edition” by Ryan Mitchell

What you’ll build: An enhanced version of your CLI reader. Instead of giving it a file of exact feed URLs, you give it a file of website URLs (e.g., https://danluu.com/). The tool will first find the RSS feed on that site and then subscribe to it.

Why it teaches RSS: It teaches the “discovery” mechanism. Most users don’t know the exact URL of an RSS feed; they just know the website. This project teaches you how browsers and feed readers find the feed automatically.

Core challenges you’ll face:

  • Fetching a webpage’s HTML → maps to another HTTP GET request
  • Parsing HTML → maps to navigating an HTML document to find specific tags
  • Finding the feed <link> tag → maps to searching the <head> of the HTML for <link rel="alternate" type="application/rss+xml">
  • Extracting the href attribute → maps to getting the URL of the feed from the tag you found

Key Concepts:

  • HTML <head> section: Where metadata about a webpage lives.
  • <link> tag: Used to define relationships between a document and external resources.
  • HTML Parsing: Using a library like BeautifulSoup makes this much easier than string matching.

Difficulty: Intermediate Time estimate: 1 day Prerequisites: Project 4.

Real world outcome: Your reader can now be given a file sites.txt containing https://jvns.ca/ and it will automatically find and subscribe to https://jvns.ca/atom.xml.

Implementation Hints:

  1. Your tool will now read sites.txt instead of feeds.txt.
  2. For each site URL, first make an HTTP request to get the HTML content.
  3. Use a library like Python’s BeautifulSoup to parse the HTML.
  4. Use the library’s features to find the specific link tag. The selector you want is link[rel="alternate"][type="application/rss+xml"]. There might also be one for Atom feeds (type="application/atom+xml").
  5. Once you find the tag, get its href attribute. This is your feed URL.
  6. You may need to handle relative URLs (e.g., /feed.xml) and combine them with the original site’s domain to get an absolute URL.
  7. Once you have the feed URL, the rest of the logic from Project 4 (fetching, parsing, diffing) remains the same.

Learning milestones:

  1. Find a feed URL from a homepage → You have successfully implemented the auto-discovery process.
  2. Handle both RSS and Atom link types → You’ve made your tool more robust.
  3. Handle relative and absolute URLs → You are handling real-world HTML variations correctly.

Project 6: A Full-Stack RSS Aggregator

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go, Node.js/Express, Ruby on Rails
  • Coolness Level: Level 4: Hardcore Tech Flex
  • Business Potential: 3. The “Service & Support” Model
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Web Development / Databases
  • Software or Tool: A web framework (Flask/Django), a database (SQLite/PostgreSQL)
  • Main Book: “Designing Data-Intensive Applications” by Martin Kleppmann

What you’ll build: A web-based RSS reader like a mini-“Feedly”. It will have a backend that continuously polls feeds and stores them in a database, and a simple frontend to display them.

Why it teaches RSS: This is the culmination of all the previous projects, assembled into a real, useful application. It forces you to think about architecture, background jobs, database design, and user interfaces.

Core challenges you’ll face:

  • Database schema design → maps to creating tables for feeds, articles, and users
  • Background polling → maps to writing a separate process or using a task queue (Celery, Dramatiq) to fetch feeds without blocking the web server
  • Building a web API → maps to creating endpoints like /api/feeds, /api/articles, and /api/feeds/add
  • Building a simple UI → maps to creating an HTML/CSS/JS frontend that calls your API to display the data

Key Concepts:

  • Three-Tier Architecture: Frontend (UI), Backend (Logic), Database (Storage).
  • Background Jobs: The concept of performing long-running tasks outside of a user request.
  • REST API Design: Designing clean and logical endpoints for your UI to consume.
  • Database Normalization: Storing data efficiently without duplication.

Difficulty: Advanced Time estimate: 1-2 weeks Prerequisites: All previous projects, basic web development knowledge.

Real world outcome: A web application running locally. You can open your browser, add a feed URL, and see its articles appear. The app will automatically fetch new articles in the background.

Implementation Hints:

  1. Backend:
    • Use a web framework like Flask.
    • Use a database like SQLite to start. You’ll need tables: feeds (id, url, title) and articles (id, feed_id, guid, title, link, description, pub_date).
    • Create an API endpoint POST /api/feeds that takes a URL, discovers the feed (Project 5), adds it to the feeds table, and triggers an initial fetch.
    • Create an endpoint GET /api/feeds/<feed_id>/articles to get all articles for a feed.
    • Write a separate “worker” script. This script runs in a loop (while True: with a sleep), gets all feeds from the DB, fetches and parses them, and adds any new items to the articles table.
  2. Frontend:
    • A simple index.html file with some JavaScript.
    • The UI should have an input box and button to add a new feed URL (which calls your POST endpoint).
    • It should have a list of feeds on the side. Clicking a feed calls your GET endpoint and displays the articles in the main view.

Learning milestones:

  1. You can add a feed via the web UI → Your frontend and backend are communicating.
  2. New articles appear automatically → Your background polling worker is functioning correctly.
  3. The application state persists in the database → You have built a robust, stateful web service.

Project 7: Handling Podcasts and Images

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go, Node.js
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 3: Advanced
  • Knowledge Area: Data Parsing / Rich Content
  • Software or Tool: XML Namespaces
  • Main Book: N/A

What you’ll build: Extend your aggregator (either CLI or web) to properly handle podcasts and images. This means parsing <enclosure> tags and iTunes-specific tags.

Why it teaches RSS: It introduces you to the world of RSS extensions and namespaces. Podcasting relies heavily on RSS, but with extra tags that live in a different XML namespace (like itunes:). This is a common real-world scenario.

Core challenges you’ll face:

  • Parsing <enclosure> tags → maps to finding tags with attributes (url, length, type)
  • Handling XML namespaces → maps to parsing tags like <itunes:image> or <itunes:summary>
  • Storing media metadata → maps to adding columns to your articles table for enclosure_url, enclosure_type, image_url
  • Displaying rich media → maps to using <img> tags for images and <audio> tags for podcasts in your frontend

Key Concepts:

  • XML Namespaces: How XML avoids tag name collisions by prefixing tags (e.g., itunes:).
  • The <enclosure> tag: The standard way to attach media to an RSS item.
  • Podcasting RSS extensions: The set of itunes: tags that power the podcast ecosystem.

Difficulty: Advanced Time estimate: 2-3 days Prerequisites: Project 6.

Real world outcome: When you add a podcast feed to your web aggregator, you now see the podcast’s cover art and an embedded HTML5 audio player to listen to the episode.

Implementation Hints:

  1. In your XML parser, you’ll need to tell it about the namespaces. In Python’s ElementTree, you pass a namespaces dictionary to the find method.
    • Example: item.find('itunes:image', namespaces={'itunes': 'http://www.itunes.com/dtds/podcast-1.0.dtd'})
  2. The <enclosure> tag is a standard RSS tag. It will have attributes, not text content. You need to get enclosure.attrib['url'].
  3. Update your database schema and your Article data class to store this new information.
  4. In your frontend, when displaying an article, check if article.enclosure_type starts with audio/. If so, render an <audio controls src="..."></audio> tag. If it starts with image/, render an <img> tag.

Learning milestones:

  1. Your parser extracts enclosure URLs → You can parse tag attributes.
  2. Your parser extracts iTunes cover art → You understand and can handle XML namespaces.
  3. Podcasts can be played from your web UI → You have successfully integrated rich media into your application.

Project 8: Creating a JSONFeed Converter

  • File: LEARN_RSS_DEEP_DIVE.md
  • Main Programming Language: Python
  • Alternative Programming Languages: Go, Node.js
  • Coolness Level: Level 3: Genuinely Clever
  • Business Potential: 2. The “Micro-SaaS / Pro Tool”
  • Difficulty: Level 2: Intermediate
  • Knowledge Area: Data Transformation / Modern APIs
  • Software or Tool: JSON, JSONFeed spec
  • Main Book: N/A

What you’ll build: A tool that takes an RSS feed URL, parses it with your library from Project 2, and outputs a valid JSONFeed version of it.

Why it teaches RSS: It solidifies your understanding by forcing you to map the concepts of RSS (channel, item, guid) to a different, more modern format. It proves you understand the semantics of a feed, not just the XML syntax.

Core challenges you’ll face:

  • Understanding the JSONFeed spec → maps to reading a technical specification and understanding its structure
  • Mapping RSS concepts to JSONFeed concepts → maps to channel -> feed, item -> item, guid -> id, link -> url
  • Generating correct JSON → maps to building a Python dictionary with the right structure and serializing it to a JSON string

Key Concepts:

  • JSONFeed Specification: The official spec at jsonfeed.org.
  • Data Mapping: The process of converting data from one schema to another.
  • JSON Serialization: Converting a native data structure (like a Python dict) into a JSON string.

Difficulty: Intermediate Time estimate: 1 day Prerequisites: Project 2.

Real world outcome: A script that can convert an XML feed to JSON:

$ python to_json.py https://example.com/feed.xml > feed.json

The resulting feed.json file is a valid JSONFeed that could be consumed by a modern feed reader.

Implementation Hints:

  1. Read the JSONFeed spec. It’s very simple.
  2. Use your RSS parser from Project 2 to get a list of Article objects.
  3. Create a top-level Python dictionary that will become your JSONFeed.
    • 'version': 'https://jsonfeed.org/version/1.1'
    • 'title': 'Title of the original feed'
    • 'home_page_url': 'Link of the original channel'
    • 'feed_url': 'The URL of the original RSS feed'
    • 'items': [] (an empty list)
  4. Loop through your Article objects. For each one, create an item dictionary and append it to the 'items' list.
    • 'id': article.guid
    • 'url': article.link
    • 'title': article.title
    • 'content_html': article.description
    • 'date_published': article.pubDate.isoformat() (if you parsed it to a datetime object)
  5. Use Python’s json.dumps() to convert the top-level dictionary into a pretty-printed JSON string.

Learning milestones:

  1. A JSON file is created → You understand basic data serialization.
  2. The file validates as a JSONFeed → You have successfully mapped one spec to another.
  3. The JSON is more pleasant to work with than the original XML → You appreciate why modern formats like JSON are popular for APIs.

Summary

Project Difficulty Time Main Concept Taught
1. Manual Fetcher Beginner Hours HTTP & Raw XML Structure
2. Proper Parser Intermediate 1 Day XML DOM & Data Structures
3. Feed Publisher Intermediate 1 Day The RSS Specification
4. CLI Reader Intermediate 1 Day State Management (Diffing)
5. Auto-Discovery Intermediate 1 Day HTML Parsing & Discovery
6. Full-Stack Aggregator Advanced 1-2 Weeks Databases & Background Jobs
7. Podcast/Image Support Advanced 2-3 Days XML Namespaces & Rich Media
8. JSONFeed Converter Intermediate 1 Day Data Transformation & APIs