DEV Community: almasi-y

Django: Figuring out the MVT Architecture Versus the MVC

almasi-y — Tue, 01 Jul 2025 17:48:54 +0000

What exactly is an architecture in a framework

You might be wondering: why do we need an architecture in a framework.
Well, an architecture in a framework in layman's term it's the way the framework is layered or arranged, how it will be operating and interacting with its components for example view in this case has to be interacting with models and templates

The Model View and Template

Model – A model is an object that defines the structure of the data in that particular app it is in. It's responsible for maintaining the data and handling the logical data structure for the entire web application.
Views – A view is a function that handles the Http requests and responses. It will accept the requests, process them and return the Http responses.
Templates - Templates are files that define the structure of the entire User Interface completely. It handles the static components of the webpage, including the HTML that users encounter.
So now that we know what an architecture is and the definition of each component in a MVT architecture, it's much easier then to introduce the fact that the MVT is sort of a control flow.

-This control flow starts immediately when a user interacts with a Django web page as shown below:

The Control Flow
Here are the steps that fall into place when a user interacts with a Django application:

For a user to interact with the django app they have to use a url, so the user sends a url request
Using a URL mapper, the request will be redirected to the appropriate view if it is there
Once the view is found it is then called because again it is a function, remember
The view now communicates with the model to retrieve or for the model to give the data requested by the url
The view also communicates with the template and populates it with the data it has received from the models and sends it to the user interface

MVT VERSUS MVC

You have now gotten the jist of what MVT architecture is and how it essentially works, so now how is the conventional MVC(Model View Controller) different from this.

Handling user input and updating model and views:- In MVC the controller is responsible for this role while in MVT the role is shared between handling of routes that is in-built in django and the views functions
The view in MVC depends on the controller for data as it defines what the user sees while the view in MVT interacts directly with the model hence combining logic and user interface

MVT overtakes MVC when it comes to simplicity. Because MVT does not have a controller that separates the logic, routing and user interface, there is less boilerplate code hence simplifying development

References
https://www.educative.io/answers/what-is-mvt-structure-in-django
https://www.askpython.com/python-modules/django/django-mvt-architecture

Basic Structure for a Django Project

almasi-y — Mon, 30 Jun 2025 19:04:27 +0000

To learn about the Django structure we first need to initialize a project
For that we need to write the command below in a terminal

django-admin startproject config

Of course this is assuming that the name of your django project is called config, it should look like this

Files in the project directory

In the config directory we see the following files:
- asgi.py: This is the file responsible for asynchronous server gateway interface
- settings.py: This is the file where we will configure the settings that apply to our entire django project
- urls.py: Here we configure the urls in our django project
- wsgi.py: This file is responsible for rendering pages in the web
- init.py: This file tells python that the files in this folder are a python package and that they can be imported in other files too

Applications in the django project

For this particular config project, I have created 2 apps in it.

users
posts
Notice the naming convection of the apps, they are in plural so that their respective models will be in singular that is: User and Post respectively.
So to create the apps we simply run the following commands

cd config
manage.py startapp users
manage.py startapp posts

Once you run the following you should get something that looks like this

In each of the following apps we have these files and a folder
- views.py: This file has views which receive a web request and returns a web response
- admin.py: This is the default layout of the admin page which ius already pre-built in django
- init.py: This file marks this particular file as a python package
- apps.py: This file allows you to define metadata specific to this app
- models.py: This is the file that contains your database layout
- tests.py: This file contains tests for debugging the app
- migrations folder:

Templates

After creating our apps we have to create template folders in each of them.
In the templates, respectively there should be another folder with the same name as the app and within this folder is where we can place the html files

Python Data Types

almasi-y — Fri, 27 Jun 2025 09:07:53 +0000

PYTHON DATA TYPES😄

Types of data types

1️⃣ Numeric data types
int

An integer, is a whole number, positive or negative, without decimals, of unlimited length.

 numbers = 20
 print(numbers)
 print(type(numbers))

float

A float is a number, positive or negative, containing one or more decimals.

 my_float = 20.5
 print(float)
 print(type(float))

complex

A complex is a number made up of some parts that are unknown

 my_complex = 1j
 print(my_complex)
 print(type(my_complex))

2️⃣ Sequence Types
lists

Lists are used to store multiple items in a single variable.
Take note of the square brackets
Unlike a set, a list can allow duplicate values
They can contain different data types

 fruits = ["apple", "banana", "cherry"]
 print(fruits)
 print(type(fruits))

tuple

Tuples are used to store multiple items in a single variable.
Take note of the round brackets
Unlike lists, tuples are unchangeable.
Allows duplicate members.

 cars = ("toyota", "porsche", "mercedes")
 print(cars)
 print(type(cars))

range

A range is a sequence of numbers starting from 0 by default and increments by one

 my_range = range(6)
 print(my_range)
 print(type(my_range))

3️⃣ Mapping types

dict

Dictionaries are used to store data values in key:value pairs.
Dictionaries are ordered and changeable
Like sets they do not allow duplication of items

 my_dict = {"name" : "John", "age" : 36}
 print(my_dict)
 print(type(my_dict))

4️⃣ Set types
set

Sets are used to store multiple items in a single variable.
Sets are unindexed, unordered and unchangeable however you can add or remove items from a set
Sets also do not allow duplicates
Take note of the curly braces

my_set = {"gold", "silver", "titanium"}
print(my_set)
print(type(my_set))

frozen set

Similar to a set but completely immutable; you cannot add or remove items

my_frozenset = frozenset({"apple", "banana", "cherry"})
print(my_frozenset)
print(type(my_frozenset))

5️⃣ Boolean types
boolean

A boolean is a value that can be true or false

my_bool = True
print(my_bool)
print(type(my_bool))

6️⃣ Binary types
bytes

Bytes represent an immutable sequence of 8-bit values

z = b"Hello"
print(z)
print(type(z))

bytesarray

Bytesarray represents a mutable sequence of 8-bit values.

my_bytearray = bytearray(5)
print(my_bytearray)
print(type(my_bytearray))

memoryview

A memoryview object provides a view into the memory of a bytes-like object (like bytes or bytearray) without copying the underlying data.

my_memoryviews = memoryview(bytes(5))
print(my_memoryviews)
print(type(my_memoryviews))

7️⃣ None types
NoneTypes

This is simply a data type that represents an absence of value

z = None
print(z)
print(type(z))

8️⃣ Text types
string

A string is a collection of characters

greetings = "Hello World"
print(greetings)
print(type(greetings))

What is Version Control and How does it Work

almasi-y — Thu, 26 Jun 2025 11:15:23 +0000

🌠VERSION CONTROL 🌠

Version Control is a lifesaver or rather software development lifecycle saver, without it software development would be dirty mess. My favorite analogy is an 100-piece orchestra without a conductor; chaotic, huh! 🤔
So version control systems are basically systems that track and manage changes made to source code.
The most widely used VCS is Github, which I use. Github is a distributed VCS that:
- Users access the repository from any location hence distributed
- Contributors can work on the same codebase without being on the same network
- Each developer has a local copy of the entire repository and history on their device
- Users can commit, branch, and merge changes locally without reliance on the central server

🤖WHAT TO KNOW ABOUT GITHUB🤖

Forking

Forking comes in handy when you are trying to fix an issue or propose some changes in the upstream repository, that is the repository in which changes are pushed to.
A fork then is basically a copy of another user's repository in your own account
To fork:
- Head on to the github repository you would like to fork
- On the top left corner click the button, fork
- Click create a fork
- Now you have your own copy of that repository

Collaboration

Collaboration is when users can invite collaborators(anyone with read and write access to a repository who has been invited to contribute by the repository owner) to a repository, manage their access permissions, and track changes through commits and pull requests.
- Allowing teams to work together on projects, review each other's code, and integrate changes efficiently.

Pull requests

Pull requests are proposed changes to a repository to be merged, that are submitted by a user.
The proposed changes can be accepted or rejected by a repository's collaborators.
The collaborators can also choose who to give permissions to pull requests.

Merge Conflicts

First off what is a conflict, it's when different changes have been done by different collaborators on the same file, thus a conflict.
When this happens, the developer has to merge, that is to choose which changes to keep or discard for a harmonious merge.

Code Review

Code reviewing is the examining of code changes proposed in a pull request to identify potential issues, suggest improvements, and ensure that the code is not going to negatively interfered with.
- The work reviewers do
- Reviewers analyze the code changes, looking for potential bugs, issues, or areas for improvement.
- They can leave comments directly on the code, highlighting specific lines or sections that need attention.
- Comments can be general feedback, specific suggestions, or requests for clarification.
- Reviewers can also initiate a formal review, which allows them to bundle multiple comments and submit them together.

Github Issues

Issues are used to track ideas, feedback, tasks, or bugs.
Also there are a number of ways to create an issue like via Github CLI or via projects, via discussions, from repo, from code, from comments and from URL query
GitHub CLI is an open source tool for using GitHub from your computer's command line. When you're working from the command line, you can use the GitHub CLI to save time and avoid switching context.
To create an issue, use the gh issue create subcommand. To skip the interactive prompts, include the --body and the --title flags.

gh issue create --title "My new issue" --body "Here are more details."

You can also specify assignees, labels, milestones, and projects.

gh issue create --title "My new issue" --body "Here are more details." --assignee @me,monalisa --label "bug,help wanted" --project onboarding --milestone "learning codebase"

Github commands

There are many commands used but the most common ones are these
git clone
git push
git pull
git commit -m "message"
git add

Pushing changes to github

To push the changes you made on your local branch to the remote repository just use the git push command like so:
Keep in mind the git push command takes two arguments: A remote name, for example, origin and a branch name, for example main

git push REMOTE-NAME BRANCH-NAME

Installing key components in kickstarting a 20-day bootstrap for Django

almasi-y — Tue, 24 Jun 2025 21:34:33 +0000

We will need to install and or set up the following:

Text Editor (VS Code)
Python 3.10 +
WSL
Connect github with github ssh
Git
Docker

Text Editor(VS Code)

What to do:

Download VS Code by following the link https://code.visualstudio.com/download
- Be sure to choose a version that is compatible with your hardware
Run it on your computer and voila

Python 3.10+

What to do:

Head over to https://www.python.org/downloads/
Select to download the version of python you would prefer preferably the latest on 3.13 and again check for compatibility
Run the package and now you have these installed -the IDLE -the Module Docs -the python cli

WSL

What to do:

Open PowerShell or Windows Command Prompt in administrator mode by right-clicking and selecting "Run as administrator"
Enter the wsl --install command, then restart your machine. -This command will enable the features necessary to run WSL and install the Ubuntu distribution of Linux. (This default distribution can be changed).

Connect github with github ssh

What to do:

Check for existing SSH Keys
ls -al ~/.ssh.
This lists the files in your .ssh directory.
- Looked for files like id_rsa.pub, id_ecdsa.pub, or id_ed25519.pub. If they are not there generate them.
Generating keys
- Run ssh-keygen -t ed25519 -C "almasavrl@gmail.com" Replace "almasavrl@gmail.com" with your actual GitHub email address.
- Put a passphrase(optional) or press enter
- Enter for the location of the ssh files to be in default location.
Add the SSH Key to the SSH Agent
- Start the SSH agent in the background: eval "$(ssh-agent -s) ssh-add ~/.ssh/id_ed25519
Adding the SSH Key to my GitHub Account

cat ~/.ssh/id_ed25519.pub
Copy the ssh key in github
- Head to my profile, settings then SSH and GPG settings added the new SSH key.
Test Your SSH Connection:
ssh -T git@github.com
- You should see a success message as such: Hi USERNAME! You've successfully authenticated, but GitHub does not provide shell access.

GIT

What to do:

Head on over to https://git-scm.com/downloads on your browser
Download the version required by respective operating system
Run the execute file and you should have git installed in a folder containing -git bash -git gui -git cmd
Further setting up of github email and username can be done in the bash

Docker

What to do:

Head on over to https://www.docker.com/get-started/
Click on download Docker desktop
Run the executable files and docker should be installed
Of course create an account or sign up via google or github

Installing key components to kickstart a 20-day bootcamp for django

almasi-y — Tue, 24 Jun 2025 19:39:11 +0000

CONNECT GITHUB WITH GITHUB SSH KEYS

For this step, check for existing SSH Keys and I did that on ubuntu bash and wrote ls -al ~/.ssh. This lists the files in your .ssh directory. Looked for files like id_rsa.pub, id_ecdsa.pub, or id_ed25519.pub. They were not there so next is generating them.
Have to run ssh-keygen -t ed25519 -C "youremail@gmail.com"
Replace "your_email@example.com" with your GitHub email address.
Personally I did not put a passphrase and the location of the ssh files are in the default location.
Add the SSH Key to the SSH Agent
Start the SSH agent in the background:
eval "$(ssh-agent -s)
Add your SSH private key to the agent:
ssh-add ~/.ssh/id_ed25519
Finally to have the ssh keys set up:
Adding the SSH Key to my GitHub Account
cat ~/.ssh/id_ed25519.pub
I copied the ssh key then headed to my profile,settings then ssh and gpg settings added the new ssh key.
Test Your SSH Connection:
ssh -T git@github.com
But I got a message about fingerprints I did not understand, eventually I got the message
Hi USERNAME! You've successfully authenticated, but GitHub does not provide shell access.

DOCKER

At this point I feel like I am an expert because I know that docker is; a container, see expert. Headed to google typed in docker install windows because my laptop has windows 64 bits but what is the difference between ARM and AMG, food for thought. Run it, and either create a docker account or sign in via google or github, I used google easy.

WSL

I installed Windows Subsytem for Linux by first installing ubuntu 24.0.0 via microsoft store, and it installed wsl by default, set up ubuntU and I had wsl.

VS Code

Prior to this bootcamp I had VS Code already installed and these were the steps I took.
So go straight ahead to google, type in vs code install and after it downloads run it and voila you have vs code app ready to go

GIT

Then later into my learning journey I installed git. Basically same steps as I did with vs code only this time type git install windows, run it and now you have; git bash, git gui and some git documentation as well.