Forem: Hannah

Django Architecture: What I Wish I Knew About Django’s Architecture Sooner "MVC vs MVT" Explained;

Hannah — Wed, 02 Jul 2025 05:47:49 +0000

Imagine building a house without a blueprint—walls might overlap, rooms could become inaccessible, and chaos would reign. Similarly, web apps need a clear structure to stay organized and maintainable. This is where architectural patterns like MVC and MVT come in!

Brief context:

Django, a popular Python framework, follows the Model-View-Template (MVT) pattern.

Beginners often confuse MVT with the traditional Model-View-Controller (MVC).

This article will clarify the differences and explain Django’s unique approach.

What is MVC?

MVC stands for Model-View-Controller, a software design pattern that separates an application into three main components:

1.Model: Handles data and business logic

2.View: Handles display and user interface

3.Controller: Handles user input and mediates between Model and View

How Django Implements This Pattern

Let’s break it down with a blog website example:

1.User Action

A visitor clicks "View Post" on /post/1.

2.Controller

Receives the request: "Show me Post ID 1".

Asks the Model to fetch the data.

3.Model

Talks to the database: "Get Post WHERE id=1".

Returns the post data (title, content, author).

4.Controller

Passes the data to the View.

5.View

Renders an HTML template with the post data.

MVC in Popular Frameworks

Framework   Language    MVC Implementation
Ruby on Rails   Ruby    Controllers (*.rb), Views (*.erb), Models (ActiveRecord)
Laravel PHP UserController.php, User.php (Model), Blade templates
ASP.NET MVC C#  UserController.cs, User.cs, Razor Views
Django (MVT)    Python  views.py (Controller), models.py, Templates

Traditional MVC Architecture

Code Structure

app/
  ├── models/          # Model (User.rb)
  ├── controllers/     # Controller (UsersController.rb)
  └── views/           # View (users/index.html.erb)

What is MVT Architecture?

Let me dive deeper into Django's Model-View-Template (MVT) architecture to give you a comprehensive understanding in this article.

The key components are:

Model
View (Django's "Controller")
Template (Django's "View")

Key Differences: MVC vs. MVT

Component   Traditional MVC       Django’s MVT
Logic        Controller           View
UI           View                 Template
Data         Model                 Model
Routing      Part of Controller     URL Dispatcher

How MVT Works

Final Verdict: MVC vs. Django’s MVT

Both MVC (Model-View-Controller) and MVT (Model-View-Template) are architectural patterns designed to organize code for maintainability and scalability. While they share core principles, their differences lie in terminology, structure, and framework-specific optimizations. Here’s the ultimate comparison to help you choose or understand their roles.

Both patterns solve the same problem, just in slightly different ways.
Choose the tool that fits your project, and happy coding! 🚀

How to Set Up a Django Project Structure Using VS Code

Hannah — Mon, 30 Jun 2025 18:55:21 +0000

If you're just getting started with Django and want to build your project using Visual Studio Code (VS Code), you're in the right place. In this guide, I’ll walk you through setting up a clean Django project structure from scratch using VS Code — perfect for beginners and those who want a solid foundation for scalable web apps.
Before l dive in, make sure you have the following installed:

Python (3.13 or higher).

2.pip.

3.virtualenv.

📁 Step 1: Create Your Project Folder.
Open VS Code and create a new folder;

`mkdir my_django_project
cd my_django_project

after the creating this how they will look like;

🧪Step 2: Set Up a Virtual Environment
Virtual environments are essential in Python development—especially for Django projects. Each Python project might require different versions of packages. A virtual environment keeps dependencies isolated so that one project’s requirements don’t interfere with another’s.
we need to Create and activate a virtual environment;

python -m venv env
# On Windows
env\Scripts\activate
# On macOS/Linux
source env/bin/activate

📦Step 3: Install Django.
Once your virtual environment is activated, the next step is to install Django — the powerful web framework that will power your project.
Install Django using pip;

pip install django

After install it look like this;

then after that run the server

python manage.py runserver

then it click the link and it brings success of install of django

🚀Step 4: Start a New Django Project

Now create your Django project

use the command;

`django-admin startproject <project_name>`

Your folder structure should now look like this:

my_django_project/
├── config/
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
└── env/

Step 5: Create a Django App

Installed the required django apps l used command to create the apps which they were two apps;

Now your structure will look like this ;

but for the second app this how structure will look like;

🧱Step 6:Creating Models

Each app will have its own views and templates. Here’s how to link them and display two templates from each.

`blog/
└── templates/
└── blog/
├── home.html
└── about.html

portfolio/
└── templates/
└── portfolio/
├── home.html
└── projects.html``

🌐Step 7: Set Up URLs

In Django, URLs are how you connect your web browser to specific views in your app. Think of them as the road signs that tell Django which view to display when someone visits a certain page.
this how it look like;

Step 8: Set Up html

In Django, HTML is used to build the templates that define how your web pages look. These templates are combined with data from your views to create dynamic, interactive websites.

l added them this how it look liked;

✅ Final Result

Now you can run the project and see how it look;

run using;

python manage.py runserver

this how it will look like;

In this guide, we walked through the full process of setting up a Django project using Visual Studio Code. Here's a quick recap of what we covered:

✅ Creating a virtual environment to isolate dependencies

✅ Installing Django and verifying the installation

✅ Starting a new Django project and creating multiple apps

✅ Setting up views, templates, and URL routing for each app

✅ Understanding how HTML works within Django templates

Django is incredibly powerful once you get the hang of it—and the best way to learn is by building.

Got questions, stuck somewhere, or want to share what you built? Drop a comment below—I’d love to hear from you and help out!

happy coding

How I Learned Git and GitHub

Hannah — Thu, 26 Jun 2025 11:13:44 +0000

Halloo welcome to my article day two of git and github l will take you step-by-step of how to use git and github with your source-code editor.
1.🚀Forking
Repository is like cloning someone else’s project into your own GitHub account. Forking gave me the freedom to experiment with changes without affecting the original code.
Steps:

1.Navigate to the repository you want to fork on GitHub.

2.Click the “Fork” button (usually top-right).

3.Choose your GitHub account as the destination.

GitHub creates a copy in your account—ready to work on!
After that, you can clone the forked repo;

`git clone https://github.com/your-username/repo-name.git
cd repo-name`

2.🤝Collaboration
This a key theme in my learning. through GitHub, I realized that coding doesn’t have to be a solitary journey. I paired with peers, contributed to projects, and received feedback that shaped me into a better developer.
Steps:

1.Fork or clone a shared repository.

2.Create a new branch for your feature or fix.

3.Make changes and commit them.

4.Push the branch and open a pull request.

5.Discuss, review, and iterate on code with your team.
this are Common commands l used when working with others:

git checkout -b feature-branch     # Create a new branch for your work
git add .                          # Stage your changes
git commit -m "Your message"       # Save your changes
git push origin feature-branch     # Share your changes

3.🔄Pull Requests
This pull requests are form of access other work but I learned that a PR is just a way of proposing changes. After pushing my changes to a fork, I could create a PR to suggest them to the original repository. It became a ritual: describe what I did, request reviews.
Steps:

1.Push your branch to your fork or the main repo.

2.Click “Compare & pull request”.

3.Add a descriptive title and summary of changes.

4.Assign reviewers (if needed).

5.Submit the PR and respond to feedback.
go to your repo and click Compare & pull request.

4.⚔️Merge Conflicts
Merge conflicts—the unwelcome guests that sneak into collaborative projects. I encountered my first merge conflict while contributing to a project under active development.
Steps:

1.Attempt to merge the conflicting branches.

2.Git will highlight conflicting files.

3.Open the files and look for conflict markers (<<<<<<<, =======, >>>>>>>).

4.Edit the file to keep the desired changes.

5.Save, add (git add), and commit the resolved version.

6.Complete the merge.
Useful commands when dealing with conflicts;

git pull origin main               # Sync your branch with main
# Resolve conflicts manually in code
git add conflicted-file.js         # Mark conflict as resolved
git commit                         # Save the merge resolution

5.🧐Code Review
Through code reviews, I gained valuable insights into best practices, efficient design patterns, and bug-spotting skills. Both giving and receiving reviews helped sharpen my critical thinking. I learned to suggest improvements constructively and express gratitude for feedback I received.
Steps:

1.Review the pull request changes on GitHub.

2.Add inline comments, suggestions, or questions.

3.Approve or request changes.

4.Repeat until the code is ready to merge.

5.Merge the pull request when approved.

6.🐞GitHub Issues
GitHub Issues taught me project planning. I used them to track bugs, brainstorm features, and break down tasks. Opening a good issue involves clear descriptions, reproducible steps (if it's a bug), and appropriate tagging.
Steps:

1.Navigate to the “Issues” tab of a repository.

2.Click “New Issue”.

3.Add a clear title and detailed description.

4.Label, assign, or link the issue if needed.

5.Submit the issue and update it with progress or comments.

7.💻Git Commands
From git clone and git commit to git rebase and git stash, the command line became my daily companion. While tools like GitHub Desktop exist, mastering the terminal gave me confidence and deeper understanding. Cheat sheets helped, but consistent practice was the real game-changer.
Steps (basic workflow):

git clone – Copy a repo.

git checkout -b feature-name – Create and switch to a new branch.

git add . – Stage changes.

git commit -m "Describe changes" – Save changes locally.

git pull origin main – Sync with the latest changes.

git push origin feature-name – Push your work to GitHub.
in command bash;

git init                           # Initialize a new Git repo
git clone repo-url                 # Copy a repo to your local machine
git status                         # Check your current changes
git add filename                   # Stage changes
git commit -m "Message"            # Save the staged changes
git push origin branch-name        # Push to GitHub
git pull origin branch-name        # Get latest updates

8.☁️Pushing Changes to GitHub
Git push origin branch-name—the command I now type like muscle memory. Pushing changes is the final stage of my coding cycle. I learned to commit often, write meaningful messages, and push regularly to avoid losing work.
Steps:

1.Confirm changes are committed with git commit.

2.Use git push origin to push.

3.Visit your GitHub repo to see your updates.
the command bash

git add .                          # Stage all changes
git commit -m "Descriptive message"
git push origin your-branch-name   # Upload to GitHub

Learning Git and GitHub transformed my development workflow. The lessons weren’t always easy—I’ve broken things, lost commits, and puzzled over conflicts. But every bump in the road sharpened my skills.

If you're just starting, take it one concept at a time. Don't fear mistakes—they're the best teachers.

happy coding 😄

How l started Setting Up a Python & Django Dev

Hannah — Wed, 25 Jun 2025 07:44:07 +0000

Started with Python and Django
Hey there am hannah nyambura start with me on my article of django.
Started with Python and Django requires development from scratch which django learning back end development. This article walks you through the essential tools I installed and configured to get going on the development. The most important to ensure everything was properly installed and ready from version control tools to editors and container platforms.
This are the Tools I Installed
1.Git
2.Python 3.13
3.Vs code
4.WSL (for Linux on Windows)
5.Docker
6.GitHub SSH
I will take you step by step how to install the tool in you computer.
1.Git
Git helps manage project changes and is essential for collaboration.Git tool for any developer.

To install Git on Linux:
Go to git-scm.com
Download you version
After that go tho git bash for windows and enters this code,

Git config __user.name Git config __user.email
And your ready to go for git.
2.Python 3.13
Django runs on Python they are like brother's so the first thing I did was install the latest stable version which was 3.13.3 it matters with our version of pc. The site is
https://www.python.org/downloads/ after that go to python bash check you version if correctly installed.
3.Vs code
Why vs.code it friendly and faster after installed vs code added exterion of python in my vs code for faster use.
4.WSl
This are for linux but also windows people can use.
How this how frist Steps:
Open PowerShell as Admin and run
wsl --install
Then Restart your PC
choose your Linux to use Ubuntu
Set up username & password
5.Docker
Docker is kali but used windows to Download docker Desktop docker.com/products/docker-desktop.
Installed then check for the version used.
6.GitHub SSH
I use git and github for the key l take you through how;
1.see if using any key in git or github by using this command
ls ~/.ssh
If there none then
Generate SSH Key using this command
ssh-keygen -t ed25519 -C "your_email@example.com"
SSH agent need start the key
eval "$(ssh-agent -s)" ssh-add ~/.ssh/id_ed25519
Add the Key to GitHub
cat ~/.ssh/id_ed25519.pub
Then go to github account go settings SSH and GPG keys New SSH key paste you key and save it
Test you key
ssh -T git@github.com
successful GitHub will greet you by your username if you followed the steps.
This are the setup gave me everything I needed to start building and Django applications efficiently.l have also started back end also don't let this command or steps make you afraid just follow the steps are you be fine 😌
Feel free to connect and help each other in the setup or any question.
Happy coding 😂