DEV Community: Marvin Ochieng

Machine Learning

Marvin Ochieng — Wed, 01 Apr 2026 05:32:38 +0000

Many suggest learning linear algebra, calculus and statistics for ML, but what is the flow guide towards starting
and progressing in ML?

MVT vs MVC Architecture

Marvin Ochieng — Tue, 01 Jul 2025 14:48:16 +0000

Understanding Web Development Patterns

Web application development relies heavily on architectural patterns. Two prominent patterns are MVC (Model-View-Controller) and MVT (Model-View-Template). While MVC is the traditional and widely adopted pattern, MVT is Django's interpretation that offers unique advantages for Python web development. Let's explore both patterns, their core functions and strength

Understanding MVC Architecture

What is MVC?

MVC (Model-View-Controller) is a software architectural pattern that separates an application into three interconnected components. It was originally developed for desktop applications but has been widely adapted for web development.

Core Components of MVC

Model: The data layer that manages the application's data, business logic, and rules. It directly manages data, logic, and rules of the application.

View: The presentation layer that displays data to the user. It represents the user interface and handles how information is presented.

Controller: The intermediary that handles user input, processes requests, and coordinates between Model and View. It acts as the brain of the application.

How MVC Works

User Input → Controller → Model (data processing) → Controller → View (presentation)

The Controller receives user requests, interacts with the Model to fetch or manipulate data, and then updates the View to display the results.

Strengths of MVC

Clear Separation of Concerns: Each component has a distinct responsibility, making code more organized and maintainable.

Reusability: Models can be reused across different controllers and views, promoting code reuse.

Testability: Each component can be tested independently, improving overall code quality.

Parallel Development: Different team members can work on different components simultaneously.

Flexibility: Changes to one component don't necessarily affect others, allowing for easier modifications.

Industry Standard: Widely understood and implemented across many frameworks and languages.

Understanding MVT Architecture

What is MVT?

MVT (Model-View-Template) is Django's interpretation of the MVC pattern. It reorganizes the traditional MVC structure to better suit web development needs and Python.

Core Components of MVT

Model: Similar to MVC, it handles data structure, database operations, and business logic.

View: Unlike MVC, the View in MVT contains the business logic and acts as the controller. It processes requests and coordinates between Model and Template.

Template: The presentation layer that defines how data is displayed. It's Django's equivalent of the View in MVC.

How MVT Works

User Request → URL Dispatcher → View → Model (if needed) → Template → Response

Django's URL dispatcher routes requests to appropriate views, which then process the request, interact with models, and render templates.

MVT Example Structure

# Django MVT Example

# Model (models.py)
from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

    def get_absolute_url(self):
        return f"/users/{self.id}/"

# View (views.py)
from django.shortcuts import render, get_object_or_404
from django.http import HttpResponseRedirect
from .models import User
from .forms import UserForm

def user_detail(request, user_id):
    user = get_object_or_404(User, id=user_id)
    return render(request, 'users/detail.html', {'user': user})

def user_create(request):
    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            user = form.save()
            return HttpResponseRedirect(user.get_absolute_url())
    else:
        form = UserForm()
    return render(request, 'users/create.html', {'form': form})

# Template (users/detail.html)
"""
<!DOCTYPE html>
<html>
<head>
    <title>{{ user.name }} - User Profile</title>
</head>
<body>
    <h1>{{ user.name }}</h1>
    <p>Email: {{ user.email }}</p>
    <p>Member since: {{ user.created_at|date:"F j, Y" }}</p>
    <a href="{% url 'user_list' %}">Back to Users</a>
</body>
</html>
"""

# URLs (urls.py)
from django.urls import path
from . import views

urlpatterns = [
    path('users/<int:user_id>/', views.user_detail, name='user_detail'),
    path('users/create/', views.user_create, name='user_create'),
]

Strengths of MVT

Framework Integration: Designed specifically for Django, providing seamless integration with Django's features.

Template Power: Django's template system is more powerful than traditional view systems, with inheritance, filters, and tags.

URL-Centric: The URL dispatcher provides clean URL routing that's easy to understand and maintain.

Python-Friendly: Aligns well with Python's philosophy of simplicity and readability.

Built-in Features: Leverages Django's built-in features like ORM, admin interface, and middleware.

Rapid Development: Optimized for quick development cycles with convention over configuration.

Key Differences Between MVC and MVT

Structural Differences

Aspect	MVC	MVT
Controller	Separate Controller component	Logic handled by Django framework
View Role	Presentation layer	Business logic layer
Template/View	View handles presentation	Template handles presentation
Request Handling	Controller processes requests	View functions process requests
URL Routing	Controller-based routing	URL dispatcher with direct view mapping

Conceptual Differences

Control Flow:

MVC: User → Controller → Model → Controller → View
MVT: User → URL → View → Model → Template

Responsibility Distribution:

MVC: Controller handles business logic
MVT: View handles business logic, Django handles control flow

Difference btw MVC and MVT:

MVC: Views are often programmatic
MVT: Templates are declarative with limited logic

Why Django Uses MVT

1. Framework-Controlled Architecture

Django takes control of the "Controller" aspect, handling request routing, middleware processing, and response generation automatically. This reduces boilerplate code and allows developers to focus on business logic.

# Django handles the controller logic automatically
# No need to explicitly define controllers
def my_view(request):
    # Business logic here
    data = process_request(request)
    return render(request, 'template.html', data)

2. Template-Centric Design

Django's template system is designed to be accessible to front-end developers and designers who may not be familiar with programming logic.

<!-- Django templates are designer-friendly -->
{% extends 'base.html' %}
{% block content %}
    {% for item in items %}
        <div class="item">
            <h3>{{ item.title }}</h3>
            <p>{{ item.description|truncatewords:20 }}</p>
        </div>
    {% endfor %}
{% endblock %}

3. URL-First Approach

Django's URL dispatcher promotes clean, SEO-friendly URLs and makes routing explicit and maintainable.

# Clean, explicit URL routing
urlpatterns = [
    path('blog/', views.blog_list, name='blog_list'),
    path('blog/<int:pk>/', views.blog_detail, name='blog_detail'),
    path('blog/<slug:slug>/', views.blog_by_slug, name='blog_by_slug'),
]

4. Python Alignment

MVT aligns with Python's "batteries included" philosophy by providing more functionality out of the box while maintaining simplicity.

5. Rapid Prototyping

MVT enables faster development cycles by reducing the number of files and concepts developers need to manage.

When to Choose MVC vs MVT

Choose Traditional MVC When:

Working with non-Django frameworks (Rails, Spring, ASP.NET MVC)
Building complex applications where fine-grained control over request handling is needed
Team is already familiar with MVC patterns
Building APIs where presentation layer is minimal
Working in environments where separation of controller logic is crucial

Choose MVT When:

Using Django for web development
Building content-heavy websites with complex templates
Rapid prototyping is a priority
Team includes front-end developers who need to work with templates
Leveraging Django's built-in features like admin interface, ORM, and middleware

Best Practices for Both Patterns

For MVC Applications:

# Keep controllers thin
class UserController:
    def create_user(self, request):
        # Delegate business logic to models or services
        user_service = UserService()
        result = user_service.create_user(request.data)
        return self.render_response(result)

# Fat models, thin controllers
class UserModel:
    def create_with_validation(self, data):
        # Business logic here
        if self.validate_email(data['email']):
            return self.create(data)
        raise ValidationError("Invalid email")

For MVT Applications:

# Keep views focused
def user_create(request):
    if request.method == 'POST':
        form = UserForm(request.POST)
        if form.is_valid():
            # Delegate complex logic to model methods
            user = User.objects.create_with_profile(form.cleaned_data)
            return redirect('user_detail', pk=user.pk)
    else:
        form = UserForm()
    return render(request, 'users/create.html', {'form': form})

# Use model methods for business logic
class User(models.Model):
    name = models.CharField(max_length=100)

    @classmethod
    def create_with_profile(cls, data):
        # Complex business logic here
        user = cls.objects.create(name=data['name'])
        Profile.objects.create(user=user, **data)
        return user

Conclusion

Both MVC and MVT are powerful architectural patterns with their own strengths. MVC provides a traditional, widely-understood approach that offers maximum flexibility and control. MVT, on the other hand, is optimized for rapid web development with Django, providing a more streamlined approach that reduces complexity.

Django's choice of MVT reflects its principle of "batteries included" and rapid development. By handling the controller logic internally, Django allows developers to focus on what matters most: building features quickly and efficiently. The MVT pattern works exceptionally well for content-heavy websites, rapid prototyping, and teams that value convention over configuration.

For Django developers, embracing the MVT pattern means using the framework's full power. For developers working with other frameworks or requiring more control, traditional MVC remains an excellent choice. Understanding both patterns helps you choose the right tool for the right job and appreciate the design decisions behind different web frameworks.

Day4 of how I created two applications with a page in a Django project

Marvin Ochieng — Mon, 30 Jun 2025 14:35:06 +0000

Creating a programming environment
After selecting a folder in my text editor (VS Code), I opened the terminal to run

python -m venv env

to create an environment called env.

.env/Scripts/activate

Source env/Scripts/activate

are commands used to activate the programming environment

Installing Django
I used

pip install django

in the newly created environment to install Django

Project Directory
To start my project directory, I run:

django-admin startproject myproject

in the vs code terminal to generate root directory with project name, which in this case is called myproject

this project is blue in color as shown in the figure above

Project Setting Directory
Inside the 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 in the figure below:

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!

settings.py: Contains all the project’s settings and configurations.

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

Applications
Django projects are composed of one or more apps. Each app is a Python package that follows a certain convention. In this case I created two apps called app1 and app2 respectively
This is how I created the applications inside an already initiated Django project

manage.py startapp app1

for app1 and the picture bellow shows how it looks a text editor, which in this case is VS Code

manage.py startapp app2

for app2 and the picture below shows how it looks like in VS Code

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.

Templates
Templates(what users see, HTML and CSS) are typically stored in a templates directory within each app or in a project-wide templates directory.
The selected file that is blue in color is the template for the first app

The selected file that is blue in color is the template for the second app

This stracture helps organize Django Project making it easier to maintain, especially for begginers.

Day 2. Learning about Git and Git and Github

Marvin Ochieng — Mon, 30 Jun 2025 06:39:44 +0000

1. Forking a Repository
Go to the repo on GitHub.

Click Fork (top right).

Clone your fork:
git clone <your-forked-url>

Work on your computer, then push changes to your fork.

Collaborating on GitHub

Use issues to report problems or suggest ideas.

Assign tasks to people.

Push your code and open a pull request.

Review and discuss changes with teammates.

Communicate clearly in comments.

Creating a Pull Request

Make a new branch:
git checkout -b my-feature

Make and commit your changes:
git add .
git commit -m "what you changed"

Push your branch:
git push origin my-feature

On GitHub, click Compare & pull request.

Write a title and description, then submit.

Resolving Merge Conflicts Pull latest code: git pull origin main

If there are conflicts, fix them in the files.

Add and commit the fixed files.

Push again:
git push

Code Review Check the pull request.

Review code for quality and clarity.

Leave helpful comments.

Approve or request changes.

Managing Issues Open an issue with a title and details.

Label and assign it.

Comment updates.

Close it when done.

Basic Git Commands

git init # Start git in a folder

git clone <url> # Copy a repo

git status # Check changes

git add . # Stage changes

git commit -m "message" # Save changes

git pull # Update from remote

git push # Upload your changes

git checkout # b branch – New branch

git merge branch # Combine branches

Pushing Changes Update your branch: git pull origin main

Commit your changes:

git commit -m "message"

Push:

git push origin your-branch

Open or update a pull request.

How to set up resources for my Django journey

Marvin Ochieng — Mon, 30 Jun 2025 05:55:53 +0000

1. Introduction
Hi developers, here are the software tools I installed to start my journey in Django.
Below is breakdown of how I got everything working, from VS code to python and Git.

2. Installing Visual Studio Code
I used this link,
https://code.visualstudio.com/
to download my vs code and installed version 3.13.3

3. How to install python
I used this link,
https://www.anaconda.com/products/distribution
to download anaconda and also did the necessary procedures to install conda 24.11.3

4. How to install git
I used this link
https://git-scm.com/
to download git and installed
git version 2.49.0

Generate a new SSH key
ssh-keygen -t ed25519 -C "your_email@example.com"

How to Make Sure the Key Is Private
Run ls -l ~/.ssh/id_ed25519 in the command Prompt

Success !