DEV Community: Malicha Galma

Django Models: The Backbone of Your Database

Malicha Galma — Wed, 02 Jul 2025 19:16:15 +0000

In Django’s MVT architecture, the Model is responsible for handling everything related to the database. It defines how data is structured, stored, and accessed.

What Is a Model?
A Model is a Python class that inherits from django.db.models.Model. Each model maps to a database table, and each attribute in the class represents a column in that table.

Defining a Simple Model

python
from django.db import models
class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.CharField(max_length=100)
    date_created = models.DateTimeField(auto_now_add=True)
    def __str__(self):
        return self.title

CharField– for short text like titles or names

TextField– for longer content

DateTimeField– stores the timestamp when the object is created

Making Migrations
After defining the model:

python manage.py makemigrations
python manage.py migrate

Performing CRUD operations
Create .

python
Post.objects.create(
    title="Hello", content="My first post", author="admin"
)

Read

python
Post.objects.all()
Post.objects.get(id=1)
Post.objects.filter(author="admin")

Update

python
post = Post.objects.get(id=1)
post.title = "Updated Title"
post.save()

Delete

python
post = Post.objects.get(id=1)
post.delete()

Model Relationships.
To create relationships between tables, Django provides:

python
class Category(models.Model):
    name = models.CharField(max_length=100)

class Post(models.Model):
    title = models.CharField(max_length=200)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

This sets up a one-to-many relationship where each post belongs to one category.

Registering Models in Admin.
To display your model in the admin panel:

python
from django.contrib import admin
from .models import Post

admin.site.register(Post)

Now the model appears in the admin dashboard at
Conclusion.
Django Models make it simple to define, structure, and work with your database using just Python code. Whether you're building a blog, an inventory system, or a social network, models are the core of your data layer. Once you understand how to create and interact with them, you unlock one of Django’s most powerful features.

Django Architecture:Models, Views and Templates

Malicha Galma — Wed, 02 Jul 2025 18:32:42 +0000

A beginner-friendly explanation of Django’s core design pattern
Django is a high-level Python framework that helps developers build secure and maintainable websites quickly. One of the most important concepts that powers Django is the MVT architecture, which stands for:
Model– represents the data structure

View– contains the logic

Template– handles presentation

Although it's inspired by the MVC (Model-View-Controller) pattern, Django takes a slightly different approach by introducing Templates instead of Controllers. That said, Django doesn’t force you to stick to a particular architecture — you can organize your app the way that works best for you.

Models .
In Django, a model defines the structure of your database tables. Each model is a Python class that inherits from models.Model, and each attribute maps to a database field.

python class Users(models.Model): full_name = models.CharField(max_length=200) bio = models.TextField() def __str__(self): return self.full_nameThe above example will generate a Users table with full_name and bio as its columns.

Models contain all the necessary fields and behavior for your data. They're the layer that handles all your database interactions — from creation to querying.

Learn more: https://docs.djangoproject.com/en/5.2/topics/db/models/

Views .
A view is where your logic lives. It’s a function or class that processes a request and returns a response. It may fetch data from the model and pass it to the template, or return a redirect or even JSON.

python Copy Edit def users_list(request): users = Users.objects.all() return render(request, 'users/users_list.html', {'users': users})The above function gets all Users from the database and passes them to a template named users_list.html. Views are usually stored in a file called views.py inside your app.

Learn more: https://docs.djangoproject.com/en/5.2/topics/http/views/

Templates
Templates are HTML files that allow you to display dynamic content using Django’s templating language. They include special syntax to loop over data, show variables, or include conditional statements.

<!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>

In this example, the template loops through the list of users and renders each one. If the list is empty, it shows a fallback message.

URL configuration.
To make your view accessible via a browser, you need to connect it to a URL pattern.

python from django.urls import path from . import views urlpatterns = [ path('', views.users_list, name='users_list'), ]This connects the root URL (/) of your app to the users_list view.

How MVT works.
Here’s a quick rundown of how Django’s MVT pattern flows:

A request comes from the browser

urls.pysends the request to the right view

The view fetches data from the model

The data is passed to a template

The template renders a response as HTML

Finally
Django’s MVT architecture breaks your app into three key parts:

Model:Manages the structure and interaction with the database

View:Handles business logic and request processing

Template:Takes care of rendering the UI

This separation makes your code cleaner, easier to manage, and scalable as your project grows.

Want to take this further? I’d be happy to write a follow-up on Django Forms

Building a Django Project With Two Apps

Malicha Galma — Mon, 30 Jun 2025 19:05:40 +0000

How I Built a Django Project with Two Apps and Templates Using Git Bash & VS Code

Hey,
In this post, I’ll explain how I created a Django project named django_project using Git Bash and VS Code, and added two apps with views and templates for:

Home
About
Contact
Services

Everything is explained step-by-step to help beginners follow along easily.

Step 1: Open Git Bash and Create a Virtual Environment
To keep all the Python packages for this project separate, I created a virtual environment in Git Bash:
bash python -m venv env
Then I activated it:
bash source env/Scripts/activate
On Windows, this uses the Scripts folder inside env to activate.

Step2:Install Django
Once the virtual environment was activated, I installed Django:
bash pip install django
This made the django-admin command available.
Step 3:Start a Django Project.
Next I created the project and named it django_project:
bash django-admin startproject django_project cd django_projectThis created a folder called django_project with important files like:

manage.py– for running commands

settings.py– to configure your project

urls.py – for connecting routes

wsgi.py and asgi.py – for deployment (can ignore for now)

Step 4:Create Two Apps
In Django, apps are like separate components or features. I created two:

bash python manage.py startapp app1 python manage.py startapp app2app1 will handle the Home and About pages

app2 will handle the Contact and Services pages

Step 5:Open the Project in VS Code.
Still inside Git Bash, I opened the project in VS Code with:

bash code .This opened the full project directory in Visual Studio Code.

Step 6:Register the Apps in settings.py .
In django_project/settings.py, I added both apps under INSTALLED_APPS so Django can recognize them:

python INSTALLED_APPS = [ ... 'app1', 'app2', ]Step 7:Configure the Main urls.py File.
In django_project/urls.py, I imported include and connected both apps to the project URLs:
python from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('', include('app1.urls')), path('app2/', include('app2.urls')), ]This makes sure that URLs from both apps are recognized.

Step 8:Create Views in Both Apps
In app1/views.py:
python from django.shortcuts import render def home(request): return render(request, 'home.html') def about(request): return render(request, 'about.html')In app2/views.py:
python from django.shortcuts import render def contact(request): return render(request, 'contact.html') def services(request): return render(request, 'services.html')
Each view will load a corresponding HTML page.

Step 9:Create urls.py in Both Apps.
I created a file named urls.py in each app.
app1/urls.py:
python from django.urls import path from . import views urlpatterns = [ path('', views.home, name='home'), path('about/', views.about, name='about'), ]
app2/urls.py:
python from django.urls import path from . import views urlpatterns = [ path('contact/', views.contact, name='contact'), path('services/', views.services, name='services'), ]
Step 10:Add HTML Templates.
At the root level (same level as manage.py), I created a folder called templates, and added four files:
arduino templates/ ├── home.html ├── about.html ├── contact.html └── services.html
Each file contains basic HTML. Here's an example:

home.html: html <!DOCTYPE html> <html> <head> <title>Home</title> </head> <body> <h1>Welcome to the Home Page</h1> </body> </html>Repeat similar HTML for about.html, contact.html, and services.html.

Step 11:Configure Template Path in settings.py
In settings.py, I told Django where to find the templates:

python import os TEMPLATES = [ { ... 'DIRS': [os.path.join(BASE_DIR, 'templates')], ... }, ]
Step 12:Run the Server and Test
I went back to Git Bash and ran:

bash python manage.py runserverThen I opened the following URLs in my browser:
`
http://127.0.0.1:8000/ → Home Page

http://127.0.0.1:8000/about/ → About Page

http://127.0.0.1:8000/app2/contact/ → Contact Page

http://127.0.0.1:8000/app2/services/ → Services Page
`
All templates displayed successfully!

Conclusion.
That’s how I built a Django project using:

Git Bash for environment setup and command line
VS Code for writing and exploring code
Django apps for modular views
Templates to render dynamic web pages

This setup is great for beginners, and you can now build on it with forms, authentication, databases, or styling with CSS.

Git and Github Explained

Malicha Galma — Thu, 26 Jun 2025 13:24:56 +0000

Hey there so you’ve been hearing about Git and GitHub...
Welcome to the world of version control — where collaboration meets backup, and coding becomes way less scary.

This isn’t your average tutorial. This is you learning Git the smart, beginner-friendly, not-so-boring way.

So... What Even Is Version Control?

Imagine writing an essay, then accidentally deleting half of it. Now imagine having a magic “undo” button — not just for the last change, but for every single change ever made. That’s version control.
It helps you:

Track changes to your code over time
Work in teams without fighting over one file
Go back in time when you mess up (you will)
Collaborate without chaos The tool we use for that? Git. And where we host our Git work? **GitHub. ##Git Basics Let’s not memorize commands — let’s understand what they do.

Command	Meaning
git init	"I'm starting a project"
git clone	"Copy this repo to my laptop"
git status	"What’s the situation with my files?"
git add	"I want to include this in the next save"
git commit -m "msg"	"Save this version with a message"
git push	"Upload my changes to GitHub"
git pull	"Download latest changes from GitHub"
git merge	"Combine this branch with another"

Forking

Forking is just a fancy way of saying:

“Hey, I want to make my own copy of this project so I can mess with it.”
It’s how you:

Contribute to open source

Experiment without wrecking the original

Start customizing someone else’s code Go to a GitHub repo → Click Fork → It’s now yours. Remix it like it’s your favorite song

Collaboration

**With Git and GitHub, you can:

Create branches to work on features
Push your changes
Pull others’ updates
Review and merge work as a team Teamwork becomes less “he touched my code” and more “let’s build something amazing together”.

Pull Requests

A Pull Request (PR) is like submitting an assignment:

You fork → clone → make changes.
You push your changes.
You open a PR and say: "Hi maintainer, here’s what I changed and why."
They review it. You fix stuff. They merge it. You celebrate A PR isn’t just a request — it’s a conversation about code.

Merge Conflicts

**Merge conflicts happen when:

You and someone else edit the same line in the same file. Git freaks out and marks the conflict like this:

bash HEAD Your changes Other person's changes other-branch

**Code Reviews

**
Pull Requests usually come with code reviews, which are:

A chance to catch bugs before they grow up
A way to learn cleaner, smarter code
A form of teamwork (not judgement!)

Tip: Ask questions. Be kind. No one writes perfect code. Not even senior devs.

GitHub Issues

GitHub Issues are like a to-do list:

Report bugs
Request features
Ask questions
Organize tasks

You can label them, assign them, and even link them to pull requests. Organized code = happy devs.

Pushing Changes to GitHub

Once you’ve made some edits locally:

bash git add . git commit -m "Added something amazing" git push origin your-branch

Basic Dev Environment Setup for Beginners Using WSL on Windows

Malicha Galma — Tue, 24 Jun 2025 21:18:44 +0000

This is a basic checklist I followed to set up my developer environment on Windows using WSL and connect Git to GitHub using SSH. It's beginner-friendly and includes everything I needed to get started.

1.Git
I installed Git inside Ubuntu (WSL):
sudo apt update sudo apt install git -y
Then I set my Git identity:
git config --global user.name "your-username" git config --global user.email "your-email@example.com"
2.Python (Version 3.10+)
To check if Python is installed:
python3 --versionIf not, I installed it with:
sudo apt install python3 python3-pip -y3.Text Editor: VS Code
I used Visual Studio Code as my main editor.
I installed the Remote - WSL extension to open Ubuntu files directly in VS Code.
4.WSL (For Windows Users)
I enabled WSL by running this in PowerShell (as administrator):
wsl --installAfter restarting, I chose Ubuntu and created a Linux username.

5.Docker
I installed Docker Desktop from:

[](https://www.docker.com/products/docker-desktop)

During setup, I enabled the WSL 2 backend in Docker settings.

6.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.

HOW I SET UP GIT AND GITHUB WITH SSH ON WSL

Malicha Galma — Tue, 24 Jun 2025 19:00:57 +0000

This is how I configured Git and connected it to GitHub using SSH:
1.I installed git
2.Set my git username and email
3.I generated an SSH key-to securely connect to github(ssh-keygen -t ed25519 -C "galmalicha@gmail.com")

Added SSH key to Agent(eval "$(ssh-agent -s)" ssh-add ~/.ssh/id_ed25519) 5.I then connected it to Github 6.Tested SSH connection(ssh -T git@github.com)-that's how i got Git and Github working with SSH. This was my first time doing this setup, and now I can use Git and GitHub with SSH inside Ubuntu on Windows.