Web Application Development — Multi-Framework Sample Assignments

This repository is a teaching and reference resource for building modern web applications across multiple languages and frameworks. It contains parallel sets of sample assignments: the same application ideas implemented in different stacks, so students can compare concepts (routing, validation, persistence, auth, websockets, webhooks) rather than memorizing one framework.

The examples are intended to support:

• a web applications course (concepts + practical labs)
• a backend programming course (patterns, API design, security, maintainability)

Language Note (Forgejo/Gitea UI)

If you are viewing this repository in a Forgejo/Gitea web interface, the site may automatically display the README that matches your current UI language.

• English version: README.md
• Polish version: README.pl.md
• To switch what the site shows, use the language selector in the page footer (the change typically applies to the current session).

(PL: Jeśli przeglądasz to repozytorium w interfejsie WWW Forgejo/Gitea, serwis może automatycznie wyświetlać README dopasowane do języka strony. Wersja EN: README.md, wersja PL: README.pl.md. Język można zmienić w selektorze na dole strony — zwykle obowiązuje dla bieżącej sesji.)

Repository Structure

At the top level, each technology has its own directory:

web_application_development/
├── docs/                      # course documentation and lab assignments
├── fastapi-assignments/        # 10 sample apps in FastAPI
├── flask-assignments/          # 10 sample apps in Flask
├── django-assignments/         # 10 sample apps in Django (REST + templates)
│   ├── restapi/                # Django REST Framework variant
│   └── classical/              # server-rendered (templates) variant
├── hono-assignments/           # 10 sample apps in Hono (Node.js)
└── rust-assignments/           # 10 sample apps in Rust (Axum)

Inside each *-assignments/ directory:

• there is a main README.md describing all 10 projects
• each project is in its own folder (e.g. 01-basic-todo-api/) with a dedicated README.md

The 10 Project Topics (Common Across Stacks)

Each technology directory contains the same set of example topics:

1. Basic To-Do API (CRUD)
2. Personal Blog (content, slugs)
3. User Profile + Uploads (multipart + static/media serving)
4. Task Manager + Background Work (non-blocking tasks)
5. Weather Dashboard (external API integration + caching)
6. Real-time Chat (WebSockets)
7. Forms + Templates (server-rendered UI + form submissions)
8. Webhook Receiver (HMAC verification)
9. Inventory Management (pagination + API versioning)
10. Secure Document Vault (authentication + authorization/RBAC)

Technology Summary (What Students Learn in Each Stack)

• FastAPI (Python)
  Strong focus on type-driven request validation (Pydantic), automatic OpenAPI docs (/docs), and fast iteration for API-first backends. To run: Python 3.10+, pip install fastapi uvicorn[standard], then start with uvicorn main:app --reload inside a chosen example folder.

• Flask (Python)
  Minimalist and explicit: routing, request parsing, templates, and extensions. Good for understanding what a framework does “by hand”. To run: Python 3.10+, pip install Flask (plus any per-example extras like SQLAlchemy), then python app.py inside a chosen example folder.

• Django (Python)

  • REST API (Django REST Framework): serializers, permissions, authentication strategies, and production-style API patterns. To run: pip install Django djangorestframework, then python manage.py migrate and python manage.py runserver in the selected project folder.
  • Classical Django (Templates): server-rendered HTML, forms, sessions, and the “traditional” MVC-style architecture. To run: pip install Django, then python manage.py migrate and python manage.py runserver in the selected project folder.

• Hono (JavaScript / TypeScript)
  Web-standards-first approach (Request/Response, fetch model). Great for modern serverless/edge-style thinking and fast prototyping in Node. To run: Node.js 18+, npm install, then npm run dev inside a chosen example folder.

• Rust + Axum (Rust)
  Demonstrates how the same web patterns look in a strongly typed, compiled language. Emphasizes correctness, explicit error handling, and performance-friendly concurrency. To run: install the Rust toolchain (rustup, cargo), then cargo run inside a chosen crate folder (or run from the workspace).

How to Use This Repository (By Course)

• Web Applications course

  • Start with docs/ (labs and conceptual explanations).
  • Use FastAPI/Flask/Django examples to reinforce HTTP, routing, forms, templates, databases, and auth.

• Backend Programming course

  • Compare the same project topic across stacks to understand design choices:
    • request validation (Pydantic vs DRF serializers vs manual validation)
    • middleware patterns
    • background work models
    • authentication and authorization strategies
  • Use Rust/Axum and Hono examples to see alternative ecosystems and tooling.

Professional Notes

• Some examples include placeholder secrets (e.g., webhook secrets, JWT keys) strictly for learning. In production, secrets must come from environment variables and never be committed.
• Not every stack generates interactive API docs by default (e.g., Flask). Where a framework does not provide /docs, the project README.md shows how to test endpoints.
• Rust examples require a local Rust toolchain (rustup, cargo) to build and run.

Quick Links

• FastAPI examples: fastapi-assignments/
• Flask examples: flask-assignments/
• Django examples: django-assignments/
• Hono examples: hono-assignments/
• Rust (Axum) examples: rust-assignments/