DEV Community: Chemutai Brenda

Day 5: Django Architecture: Models, Views and Templates.

Chemutai Brenda — Tue, 08 Jul 2025 13:36:42 +0000

python #learning #frontend #development

Today I focused on understanding and applying Django’s MVT(Model View Template) architecture, (model, views and templates) the foundation of how Django apps work.

## MODEL – Data layer.
So what is a Model in Django?
I understood Model as a Python class used to define the structure of your database.

Django uses it to create tables automatically, based on your field definitions.

It handles all data-related operations: Create, Read, Update, Delete (CRUD). For example in my previous project I added this kind of model.

from django.db import models

class Item(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

## VIEW – Logic Layer
What is a View in Django?
A View is a Python function (or class) that handles the logic behind a page.

It receives a request, fetches data (usually from the Model), and returns a response (usually a rendered Template).

I created a view to fetch data from the database and send them to the template:

from django.shortcuts import render

def home(request):
    return render(request, 'app1/home.html')

## TEMPLATE– Presentation Layer
You are probably wondering what is a Template in Django?

A Template is an HTML file used to display content to the user.

It uses Django’s built-in Template Language (DTL) to display variables, loop through data, and include logic.
So in both apps I used the the templates as in the previous article.

<!-- blog/templates/blog/post_list.html -->

<!DOCTYPE html>
<html>
<head>
    <title>My Users</title>
</head>
<body>
    <h1>All Users</h1>
    {% for user in users %}
        <div>
            <h2>{{ user.full_name }}</h2>
            <p>{{ user.bio }}</p>
        </div>
    {% empty %}
        <p>No USers available.</p>
    {% endfor %}
</body>
</html>

## URL – Routing Layer
what are URLs in Django?
The URL configuration connects user requests (like http://localhost/products) to the correct view.

URLs act like a bridge between the browser and the backend logic.
Then I used my URLs in my previous article.
URL configuration

from django.urls import path
from . import views

urlpatterns = [
    path('', views.users_list, name='users_list'),
]

HOW IT ALL CONNECTS (MVT FLOW):

User types http://localhost:8000/products/ URL routes it to views.

View calls the Product model View
Model fetches data from the database Model
View passes data to the template View
Template displays data in HTML Template
Summary of Each Part
Part Django File Purpose

View- views.py Contains logic to fetch/process data
Template templates/.html Displays data using HTML & DTL
URL- urls.py Connects browser requests to views.

Conclusion
Using the MVT architecture separates concerns cleanly:
• Model:
Defines your data.
Defines structure of database tables

• View:
Handles logic and retrieves data.
Contains logic to fetch/process data

• Template:
Renders the output.
Displays data using HTML & DTL

URLS Connects browser requests to views.

This structure helps you write clean, maintainable code and scale your project efficiently.

My Reflection on Day 5

Understanding how each MVT part plays its role helped me finally see Django as a full web framework — not just scattered files. Now I can create real, working web pages powered by Python and databases, not just static HTML.

DAY 4 OF LEARNING DJANGO.

Chemutai Brenda — Mon, 30 Jun 2025 16:26:50 +0000

DJANGO STRUCTURE.

Today i learnt how to do a set for creating a project using Django.

Step 1:
Set up
Creating a programming environment
I open a folder in my installed text editor(VS Code) and runed the following command in the terminal to create an environment called env.:

  python -m venv env

Inside the terminal, I used the following command to activate the environment:

.env/Scripts/activate

STEP 2:
Installing Django

I used the following command in the newly created environment to install Django.

pip install django

STEP 3:
Starting my project.

To start my project i run the following command in the vs code terminal to generate root directory with project name, which in this case is called "MyProject".

django-admin startproject myproject

STEP 4:
The Project Wide Settings.
After creating MyProject root directory, there is another directory called MyProject, just as the project name.
This other directory contains the project-wide settings and configurations as shown below in a diagram:

init.py:
A file that tells Python that all files in the directory should be considered a Python package.
Without this file, we cannot import files from another directory which we will be doing a lot of in Django and project creation.

settings.py:
Contains all the project’s settings and configurations.
Inside the settings I change the time from 'UTC' to 'Africa, Nairobi'.

urls.py:
The URL declarations for the project are a “table of contents” of your Django-powered site.

asgi.py:
allows for an optional Asynchronous Server Gateway Interface(ASGI) to be run

wsgi.py:
An entry point for Web Server Gateway Interface(WSGI) compatible web servers to serve your project. It helps Django serve our eventual web pages

STEP 5:
Applications.
-Django can be used to create multiple apps where each app is a Python package that follows a certain convention. In this case I created two apps called app1 and app2 respectively.

I run the following command from terminal to create app1:

manage.py startapp app1

I run the following command from terminal to create app2:

manage.py startapp app2

In the two apps each app came with important files like; > admin.py: Configuration for the Django admin interface.

apps.py:
Configuration for the app itself.

models.py:
Contains the database models for the app.

tests.py:
Contains tests for the app.

views.py:
Contains the request/response logic for the app.

migrations/:
Contains database migrations for the app

STEP 5:
To make Django recognize both apps, I opened mysite/settings.py and added them in INSTALLED_APPS

STEP 6:
Creating URLS and Writing views:
For app1

In app1/views.py i created this code;

from django.shortcuts import render

def app1_home(request):
    return render(request, 'app1_home.html')

I then created urls.py for app1 added the following in it

from django.urls import path
from .views import app1_home

urlpatterns = [
    path('', app1_home, name='app1_home'),
]

For app2

In app2/views.py:

from django.shortcuts import render

def app2_home(request):
    return render(request, 'app2_home.html')

Then I created app2/urls.py:

from django.urls import path
from .views import app2_home

urlpatterns = [
    path('', app2_home, name='app2_home'),
]

STEP 7
Connecting Both Apps in mysite/urls.py
Now it was time to connect both apps to the main URL configuration.

In mysite/urls.py I wrote:

from django.contrib import admin
from django.urls import path, include

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('app1/', include('app1.urls')),
    path('app2/', include('app2.urls')),
]

STEP 7:
Adding pages for HTML Pages

Templates(what users see, HTML and CSS) are typically stored in a 'templates' directory within each app or in a project-wide templates directory.
So I created a templates folder inside each app
In both app1 and app2, I made this folder structure:
For app1:

app1/
└── templates/
    └── app1/
        └── home.html

For app2:

app2/
└── templates/
    └── app2/
        └── home.html

STEP 8:
Updating views to render templates

In app1/views.py:

from django.shortcuts import render

def home(request):
    return render(request, 'app1/home.html')

In app2/views.py:

`from django.shortcuts import render

def home(request):
    return render(request, 'app2/home.html')

With this I was able to learn how to set up a Django structure for creating a project. I also managed to understand how two or more apps can be created inside one project.

DAY 3 OF LEARNING DJANGO.

Chemutai Brenda — Thu, 26 Jun 2025 12:25:07 +0000

Today i learnt about python data types:
1. Text Type.

str (string) used to incorporate texts in a code.

Example:

name = "Chenda"

2. Numerical types

int → Whole numbers
float → Decimal numbers
complex → Complex numbers with letters.

Example:

id = 25 # int
pi = 3.14 # float
z = 2 + 3j # complex

3. Boolean Type

bool → Logical values.

Example:

she_is_a_girl = True
she-is_young = False

4. Sequence types.

list → Ordered, changeable, allows duplicates
tuple → Ordered, unchangeable, allows duplicates
range → Immutable sequence of numbers.

Example:

colors = ["red", "blue"] # list
coordinates = (10, 20) # tuple
numbers = range(5) # range
fruits = ["mangoes", "apples"]

5. Set Types.

set → Unordered, no duplicates
frozen set → Immutable set.

Example:

items = {1, 2, 3}
frozen_items = frozenset([1, 2, 3])

6. Mapping Type

dict → Key-value pairs.

example:

person = {"name": "Alice", "age": 30}

7. Binary types.

bytes
byte array
memory view.

Example:

data = b"hello" # bytes
buffer = bytearray(5) # bytearray
memory = memoryview(bytes(5)) # memoryview

8. None Type.

None Type → Represents absence of a value.

Example:

result = None

DAY 2 OF LEARNING DJANGO.

Chemutai Brenda — Thu, 26 Jun 2025 08:57:02 +0000

I did research and learnt about forking, ⁠collaboration, ⁠pull requests, ⁠merge conflicts, ⁠code review, ⁠GitHub issues, ⁠git commands and ⁠pushing changes to GitHub.
To make my learning of Django easier.

1. Forking.
Forking is creating your own copy of someone else’s repository on GitHub.
When to use forking:

When you want to contribute to an open-source project.
When you want to freely experiment with changes without affecting the original. Example: Click the "Fork" button on a repo page → GitHub copies the repo to your account.

2. Collaboration.
Collaboration means working on a project with multiple people using Git + GitHub.
Tips to use during collaboration:

Use branches for features.
Push to shared repositories.
Pull updates often to stay in sync. Example of a code to run from the terminal. > # get latest changes from others git pull origin main

3. Merge conflicts.
Conflicts do occur when two people change the same line in a file, or add conflicting changes especially during collaboration.
How to resolve conflict when it occurs:

Git shows <<<<<<<, =======, >>>>>>> in the file.
Manually edit and choose the correct content.
Mark resolved Example of a code to run from the terminal.

git add filename
git commit -m "Resolved conflict"

4. Code review.
When teammates during collaboration review your pull request before merging:

Comment on code.
Suggest changes.
Approve or request changes. Code review is used for:
Maintaining quality.
Learning from feedback.
Catching bugs early.

5. GitHub Issues
Track bugs, features, or tasks in a project.
Use:

Title + description to explain the issue.
Assign team members, add labels, or link PR Example.

Title: Fix login bug
Description: When a user enters the wrong password, the app crashes.

6. Git Commands.
The following are GitHub commands:

How to clone a repo

git clone git@github.com:user/repo.git
How to check status:

git status
How to create a branch:

git checkout -b feature-xyz
How to switch from one branch to another:

git checkout main
How to add changes:

git add
How to commit changes:

git commit -m "message"
Pull updates:

git pull origin main
How to push changes:

git push origin branch-name

DAY 1 OF LEARNING DJANGO.

Chemutai Brenda — Wed, 25 Jun 2025 09:00:35 +0000

Setting up Git, Docker, Python, Text editor(vs code) and connecting git to git git SSH in readiness to learn Django framework of Python.
This is done for Windows.

Git
First thing I did was make sure Git was installed and properly configured.
Did this by getting the link to the git website and downloading it.
I also configured my user details:
git config --global user.name "Chenda001"
git config --global user.email "chendaketer@gmail.com"
Python (Version 3.13)
It is Python 3.13 to be exact.
I Downloaded it from python.org
Where I clicked on Windows installer before adding python to path and clicking install.
VS Code (text editor)
It had been the easiest to download.
link i downloaded it from: https://code.visualstudio.com/
And i chose the one compatible to my laptop.

4.Docker
I downloaded Docker for windows from the link below:
https://www.docker.com/products/docker-desktop

During setup, I enabled the WSL 2 backend in Docker settings.
GitHub SSH Setup I created an SSH key in Ubuntu: ssh-keygen -t ed25519 -C "your-email@example.com" Then added it to the SSH agent: eval "$(ssh-agent -s)" ssh-add ~/.ssh/id_ed25519 To copy the public key: cat ~/.ssh/id_ed25519.pub I pasted it into GitHub under: Settings → SSH and GPG Keys → New SSH key
To test the connection:
ssh -T git@github.com
And got:

Hi your-username! You've successfully authenticated...

Now my dev environment is ready. I can write Python code, use GitHub securely with SSH, run Docker containers, and work entirely inside Ubuntu using VS Code.

Connecting Git to Git SSH using Gitbash Step 1 :checking for an existing SSH keys. open Git Bash and run: ls -al ~/.ssh

step 2: Generating a new git SSH
Open git bash and run:
ssh-keygen -t ed25519 -C "chendaketer@gmail.com"

step 3: Starting SSH Agent and add key agent
Open Git Bash and run:
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

step 4:add the public key to GitHub
open git bash and run:
cat ~/.ssh/id_ed25519.pub

step 5:testing the SSH connection
Open Git Bash and run:
ssh -T git@github.com