DEV Community: zipporahmutanu04

Day 6: Django Models Made Simple: A Beginner’s Guide With Code Examples

zipporahmutanu04 — Thu, 03 Jul 2025 10:16:38 +0000

🎓 What is a Django Model?

When you build a web application, you almost always need to store data — like users, posts, products, comments, etc.
This data is stored in a database (e.g., SQLite, PostgreSQL, MySQL).

Instead of writing SQL queries by hand, Django lets you use models, which are simple Python classes.

📌 A Django model is just a Python class that describes what your data looks like.
📌 Django then takes that class and creates the actual database table for you.

📄 How do you write a model?
You write models in the models.py file of your Django app.

from django.db import models

class Post(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()
    published_at = models.DateTimeField(auto_now_add=True)

What does this do?
✅ Django will create a table named post.
✅ The table will have 3 columns:

title — a short text (maximum 200 characters)

body — long text

published_at — date and time when the post was created

🔨 How does Django turn models into a database table?
After you define the model:
1️⃣ Run:

python manage.py makemigrations
This tells Django to create a migration file (a plan for creating the table).

2️⃣ Run:

python manage.py migrate
This actually creates the table in the database.

🧪 Examples of Fields You Can Use
Here are some common field types:

name = models.CharField(max_length=100)  # short text
description = models.TextField()         # long text

Numbers

price = models.DecimalField(max_digits=6, decimal_places=2)
quantity = models.IntegerField()

Dates & Times

created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)

Boolean (True/False)

is_published = models.BooleanField(default=False)

Email & Slug

email = models.EmailField()
slug = models.SlugField()

🔗 How to Link Tables Together?
One-to-Many (ForeignKey)
Example: Many books → One author

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

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

Many-to-Many
Example: Students and Courses

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

class Course(models.Model):
    name = models.CharField(max_length=100)
    students = models.ManyToManyField(Student)

🧂 Options You Can Add
Make a field required or optional:

name = models.CharField(max_length=100, blank=True, null=True)
Choices

Let users choose only from a set of values:

STATUS_CHOICES = [
    ('draft', 'Draft'),
    ('published', 'Published'),
]

status = models.CharField(max_length=10, choices=STATUS_CHOICES, default='draft')

Unique
Make sure no duplicates:

email = models.EmailField(unique=True)

🏗️ CRUD: How to Use the Model in Code?
Once your model and table are ready, you can use Django’s ORM (Object Relational Mapper) to interact with your data.

post = Post.objects.create(title="Hello", body="This is my first post!")

Read

all_posts = Post.objects.all()
one_post = Post.objects.get(id=1)

Update

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

Delete

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

📐 More Advanced Examples
Automatically generate a slug

from django.utils.text import slugify

class Article(models.Model):
    title = models.CharField(max_length=100)
    slug = models.SlugField(blank=True)

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.title)
        super().save(*args, **kwargs)

Abstract Base Class
You can create reusable base models:

class TimeStampedModel(models.Model):
    created_at = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    class Meta:
        abstract = True

class Post(TimeStampedModel):
    title = models.CharField(max_length=100)

Custom QuerySet Manager

class PublishedManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(is_published=True)

class Article(models.Model):
    title = models.CharField(max_length=100)
    is_published = models.BooleanField(default=False)

objects = models.Manager()  # Default manager
published = PublishedManager()  # Custom manager

🤔 Why Use Django Models?
✅ They save you from writing SQL by hand.
✅ Keep all your data structure in one place.
✅ Automatically create and manage tables.
✅ Allow you to write Python instead of SQL.

🚀 Summary:
What you define What happens
Python class Table
Attributes Columns
Create .create()
Read .all(), .filter()
Update .save()
Delete .delete()

DAY 5: Understanding MVC and MVT Architecture – A Simple Guide for Beginners

zipporahmutanu04 — Wed, 02 Jul 2025 04:34:37 +0000

By: Zazima

📌 Introduction
In the world of software development, especially in building web applications, you’ll often hear terms like MVC or MVT. These are architectural patterns that help developers structure their code in a clean, organized, and efficient way. But what do they really mean? And what’s the difference?

In this beginner-friendly guide, we’ll explain everything you need to know about MVC and MVT in the simplest terms possible — with real-life examples!

💡 What is MVC (Model-View-Controller)?
MVC is a popular software design pattern used in building applications — especially in frameworks like Laravel, ASP.NET, and Ruby on Rails.

It helps to separate the application into three main parts:

Part    Description
Model - Handles the data, logic, and database
View  - What the user sees (HTML/CSS)
Controller   -  Handles the communication between Model and View

🧾 Real-Life Example: MVC as a Restaurant

Model: The kitchen where food (data) is prepared.

View: The menu and table — what the customer sees.

Controller: The waiter who takes the order and delivers the food.

This separation ensures everyone knows their job and doesn’t interfere with others. It keeps the application clean and easy to manage.

💡 What is MVT (Model-View-Template)?
MVT is a variation of MVC used by the Django framework in Python. It works similarly with MVT but with a slight twist.

In MVT, Django handles the controller part for you, which makes development faster and simpler.

Part    Description
Model - Handles data and database
View -  Connects the model with the template (logic)
Template   -    HTML pages that display the data (what users see)

🧾 Real-Life Example: MVT as a Restaurant (Again)

Model: The kitchen prepares the food.

View: The waiter’s brain that decides what to serve.

Template: The menu and table layout (display).

In this case, Django is the smart waiter who already knows how to connect everything without needing you to write a separate controller.

🔄 MVC vs MVT – Key Differences

Feature     MVC                   MVT (Django)
Model        Manages data and logic  Same
View         What the user sees (HTML)   Connects logic to template
Template     Not included in MVC     Used for HTML and design
Controller   You write it manually   Django handles it auto                               automatically
 Used In     Laravel, ASP.NET, Rails, etc. Django (Python)

✅ Why Use MVC or MVT?

Makes your project organized
Separates design from logic
Easier to maintain and update
Great for team collaboration
Improves code readability and reusability

🎯 Conclusion
Whether you’re using MVC or MVT, the goal is the same: to build structured, efficient, and maintainable applications.

Use MVC when your framework or language supports it (like Laravel or Ruby on Rails).

Use MVT when working with Django — it does a lot of the hard work for you.

Understanding these patterns will make you a better developer, and you’ll be able to build professional-grade applications with confidence.

🧾 Want to Remember It Easily?

🧠 MVC = Model + View + Controller (you handle everything)
🧠 MVT = Model + View + Template (Django handles the controller for you)

DAY 4: Getting started with Django: Build your first project step by step

zipporahmutanu04 — Mon, 30 Jun 2025 20:03:42 +0000

✍️ By ZeddyEem

🌱 Introduction
If you're just getting started with Django, welcome! This guide will walk you through everything you need to build your first simple Django project — from installation to creating your own HTML templates and apps.

We’ll build a simple project called Config, which has two apps:

✅ tasks – for managing daily to-do items.

✅ contacts – for saving personal or professional contacts.

Step 1:Check Versions

⚙️ Step 2: Install Django
First, make sure you have Python installed. Then install Django using pip:
pip install django

You can also create a virtual environment for better project management:

python -m venv env
source env/bin/activate    # On Windows: env\Scripts\activate
pip install django

🚀 Step 3: Start the Django Project
Create the Django project using the command:

django-admin startproject config

🧩 Step 4: Create Two Django Apps
We will build two apps inside the project:

python manage.py startapp tasks
python manage.py startapp contacts

Now go to config/settings.py and register the apps:

INSTALLED_APPS = [
...
'tasks',
'contacts',
]

🌐 Step 5: Set Up URLs
Update config/urls.py of the main to include both apps:

Create urls.py inside both apps.

📁 tasks/urls.py

📁 contacts/urls.py

💡 Step 6: Create Simple Views
📄 tasks/views.py

contacts/views.py

🎨 Step 7: Add Templates
Inside each app, create templates folders like this:

tasks/
└── templates/
    └── tasks/
        └── index.html

contacts/
└── templates/
    └── contacts/
        └── index.html

📄 tasks/templates/tasks/index.html

<!DOCTYPE html>
<html>
<head>
    <title>Tasks App</title>
</head>
<body>
    <h1>Welcome to the Tasks App</h1>
</body>
</html>

📄 contacts/templates/contacts/index.html

<!DOCTYPE html>
<html>
<head>
    <title>Contacts App</title>
</head>
<body>
    <h1>Welcome to the Contacts App</h1>
</body>
</html>

Make sure your settings.py includes:

TEMPLATES = [
    {
        ...
        'APP_DIRS': True,
    },
]

🛠 Step 8: Run the Project
Run the server:
python manage.py runserver

Visit:

http://127.0.0.1:8000/tasks/ – View your tasks app

http://127.0.0.1:8000/contacts/ – View your contacts app

🎁 Final Thoughts
Django is powerful, but the best way to learn is to start small. With this basic setup, you now have two working apps in a Django project — fully connected with HTML templates and views.

Next up, you can expand it into a complete productivity tool!

💬 Let’s Connect!
Got stuck? Have questions? Drop them in the comments or DM me.
Let’s build the future of tech, one line at a time.

🔗 Useful Commands Summary

# Create project and apps
django-admin startproject config
python manage.py startapp tasks
python manage.py startapp contacts

# Run server
python manage.py runserver

🚀Day 2: Git & GitHub Essentials – Forking, Collaboration, PRs & More!

zipporahmutanu04 — Thu, 26 Jun 2025 08:03:24 +0000

Hey everyone
Welcome back to Day 2 of my dev journey! Yesterday I shared how I set up my development environment. Today, I dove deep into something every developer needs—Git and GitHub. If you’ve ever wondered what’s the difference between a fork and a clone? or how to handle merge conflicts without panicking—this is for you!

✅ 1.Why Git? Why GitHub?

Git helps you track your code history, collaborate easily, and avoid the fear of "what if I break something?".
GitHub is where your Git projects live online so others can contribute, comment, or review.

2. Basic Git Commands I Practiced

Use code blocks and explain them simply:

git init
git add .
git commit -m "Initial commit"
git remote add origin <your-repo-url>
git push -u origin main

lets get started,

🔱

Step 1: Forking a Repository

🎯 Goal: Make a personal copy of a project to work on.

📝 Steps:

Go to the GitHub repo you want to contribute to.

Click the Fork button at the top-right.

A new copy appears in your GitHub account.

✅ You now have your own copy to work with freely.

🤝 Step 2: Cloning & Setting Up Collaboration

🎯 Goal: Download your forked repo to your computer.

📝 Steps:

Copy the repo URL from GitHub

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

Move into the folder

cd repo-name
✅ You’re ready to start working locally.

🌱 Step 3: Create a New Branch

🎯 Goal: Work in isolation from the main branch.

📝 Steps:
git checkout -b feature-branch-name

✅ Your changes are safe in this new branch.

✍️ Step 4: Make Changes and Commit
🎯 Goal: Save your changes with a message.

📝 Steps:

Stage your changes

git add .

Commit with a message

git commit -m "Add feature or fix"
✅ Your progress is recorded in Git history.

🚀 Step 5: Push Changes to GitHub

🎯 Goal: Upload your changes online.

📝 Steps:
git push origin feature-branch-name
✅ Now your changes are visible on your GitHub fork.

🔃 Step 6: Create a Pull Request (PR)

🎯 Goal: Request to merge your changes into the original project.

📝 Steps:

Go to your fork on GitHub.

Click Compare & pull request.

Add a descriptive title and summary.

Click Create pull request.

✅ You’ve asked the project owner to review and merge your work.

👀 Step 7: Code Review

🎯 Goal: Let collaborators check your work.

📝 Steps:

Reviewers may leave comments.

If changes are requested:

Make the fix

git add .
git commit -m "Fix review suggestions"
git push

✅ Code reviews help keep the project clean and consistent.

⚔️ Step 8: Resolve Merge Conflicts

🎯 Goal: Fix code clashes when multiple people edit the same line.

📝 Steps:
git pull origin main
If there's a conflict, Git will mark it like this:

<<<<<<< HEAD
your version
other version

main
Fix it manually, then:

git add .
git commit -m "Resolve merge conflict"
git push

✅ Merge conflict resolved.

❗ Step 9: Use GitHub Issues

🎯 Goal: Report bugs or suggest new features.

📝 Steps:

Go to the repo's Issues tab.

Click New Issue.

Describe the problem or idea clearly.

Submit it.

✅ A great way to manage and track tasks.

🧪 Step 10: Must-Know Git Commands

Command Description

git clone URL   Copy project from GitHub
git status  See what's changed
git add .   Stage all changes
git commit -m "msg" Save changes
git push    Upload to GitHub
git pull    Fetch latest changes
git checkout -b branch  Create new branch

✅ Final Workflow Summary

1. Fork the repository 
2. Clone to your computer 
3. Create a new branch 
4. Make and commit changes 
5. Push changes to GitHub 
6. Open a pull request 
7. Collaborate through code reviews 
8. Fix merge conflicts
9. Use issues for collaboration 
10. Repeat as needed

💬 Bonus Tip
💡 Always run git pull before you push to avoid conflicts.
🎯 Use clear commit messages and PR titles to help your teammates.

Day 1 dev setup: Installing Docker, WSL, Python, GitHub SSH (with some challenges & solutions)

zipporahmutanu04 — Tue, 24 Jun 2025 22:21:14 +0000

By: Zipporah Mutanu Kimanthi

Hello friend

Today was Day 1 of setting up my development environment as I prepare for serious coding, collaboration, and deployment work. I want to walk you through what I did, the challenges I faced, and how I overcame them — so if you're just getting started, you won't feel alone.

Tools I Needed to Set Up
Before jumping into code, I had to make sure the following were correctly installed on my Windows laptop:

✅ Git

✅ Python 3.10+

✅ Text Editor (VS Code / PyCharm)

✅ WSL (Windows Subsystem for Linux)

✅ Docker

✅ GitHub SSH Configuration

I already had the first four set up. The real work started with Docker and SSH configuration — and that’s where most of the challenges came in.

Installing Docker on Windows with WSL

Step-by-Step Installation

Downloaded Docker Desktop from https://www.docker.com/products/docker-desktop

During the install, I made sure to check “Use WSL 2 instead of Hyper-V”

Restarted my laptop

Opened WSL (Ubuntu), then verified installation using:

docker --version
docker run hey here is zippy

My First Challenge: Docker Command Not Found
When I ran docker in WSL, I got:

command not found: docker

How I Solved It:

Realized Docker Desktop must be running in the background

Also went to Docker Desktop → Settings → Resources → WSL Integration and turned on integration for Ubuntu

After restarting WSL: it worked!

Setting Up Git + GitHub with SSH (No More Password Prompts!)
This part is key if you want to push code to GitHub without typing your password every time.

What I Did:
Checked for SSH keys:

ls -al ~/.ssh
Created a new SSH key:

ssh-keygen -t ed25519 -C "myemailname@example.com"
Started the agent and added the key:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519
Copied the public key:

cat ~/.ssh/id_ed25519.pub
Pasted the key on GitHub:
GitHub → Settings → SSH & GPG Keys → New SSH key → Paste → Save

Tested connection:

ssh -T git@github.com
My SSH Challenge: “Permission denied (publickey)”
When I tried pushing to GitHub, I got:

vbnet
Permission denied (publickey)
fatal: Could not read from remote repository.

Fix:

I had copied the wrong key file (id_ed25519 instead of id_ed25519.pub)

Re-copied the correct .pub file and updated it on GitHub

Then it worked!

What I Learned
Docker is powerful but depends heavily on proper WSL setup on Windows

Docker Desktop must be running and integrated with WSL

SSH setup can be frustrating but once done, it's smooth sailing

Mistakes like copying the wrong file are normal — just retrace your steps

Always test with docker run hello-world or any word you want to use and ssh -T git@github.com

Final Tips
Use VS Code with the WSL extension for the best experience

Use git config to set your identity globally:

git config --global user.name "Your Name"
git config --global user.email "your-emailname@example.com"
Always use the SSH URL when cloning:

Now that I’ve installed and configured:

Git ✅

Python ✅

Text Editor ✅

WSL ✅

Docker ✅

GitHub SSH ✅

I'm fully set up to begin building and collaborating like a real developer.

Connect With Me
I'm Zipporah Mutanu Kimanthi, growing every day in tech, and sharing everything I learn to help others like me.

Let me know in the comments if you faced similar issues or need help!