Django Project & App Setup

1. Django's Core Philosophy: Projects vs. Apps

Before we write any commands, it's crucial to understand a core design philosophy in Django: the separation between a project and an app. Your extensive experience with modular software design in AI will make this concept intuitive.

• A Project is the entire web application. It's a container that holds the configuration, settings, and a collection of one or more apps that work together. Think of it as the complete house.
• An App is a self-contained module within a project that performs a specific function. For example, a blog, a user authentication system, or a product catalog could each be a separate app. Apps are designed to be reusable across different projects. Think of them as the rooms in the house—the kitchen, the bedroom, etc.

To solidify this distinction, please read the following brief section from the "Django Project Structure" article.

2. Creating Your First Django Project

Now, let's put theory into practice. Open your terminal and navigate to the django_project_1 directory you created in the last lesson. Make sure you activate your virtual environment. Your command prompt should have a (venv) prefix.

# Reminder: Navigate to your project folder
cd path/to/your/django_project_1

# Reminder: Activate the virtual environment (macOS/Linux)
source venv/bin/activate

# Reminder: Activate the virtual environment (Windows)
venv\Scripts\activate

The following video will guide you through creating a project, running the development server, and understanding the files Django generates.

Executing the Commands

As shown in the video, run the following command to create a project named core in your current directory:

django-admin startproject core .

• django-admin: The command-line utility for Django.
• startproject: The command to create a new project.
• core: The name we are giving our project's configuration directory.
• .: This tells Django to create the project in the current directory (django_project_1) rather than creating an extra, redundant parent folder.

Your directory structure should now look like this:

django_project_1/
├── venv/
├── core/
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

Understanding the Project Files

Let's briefly review the purpose of these generated files, which the video introduced.

• manage.py: Your project's command-line utility. It's a thin wrapper around django-admin. From now on, you will use python manage.py <command> to interact with your project. It automatically uses your project's settings.py file.
• core/: The Python package for your project. Its name is important for imports.
• core/__init__.py: An empty file that tells Python that this directory should be considered a Python package.
• core/settings.py: The heart of your project's configuration. It contains database settings, installed apps, middleware, and much more. We'll be visiting this file often.
• core/urls.py: The URL declarations for your project; a "table of contents" for your site. It maps URL patterns to the code that should handle them.
• core/wsgi.py & core/asgi.py: Entry-points for WSGI-compatible (Web Server Gateway Interface) and ASGI-compatible (Asynchronous) web servers to serve your project. You won't touch these for a while.

3. Creating and Registering a Django App

With the project "house" built, it's time to add our first "room"—an app. We'll create a simple app called portfolio that will eventually be used to showcase your projects.

The next video segment will guide you through creating and registering this app.

Executing the Commands

Run the following command from your project's root directory (where manage.py is located):

python manage.py startapp portfolio

This creates a new portfolio directory. Your project structure is now:

django_project_1/
├── venv/
├── core/
│   └── ...
├── portfolio/
│   ├── migrations/
│   │   └── __init__.py
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
└── manage.py

Understanding the App Files

Let's break down the purpose of the files inside the portfolio app.

• migrations/: This directory stores database migration files. Migrations are how Django tracks changes to your models.py file and synchronizes your database schema accordingly.
• admin.py: This file is for registering your app's models with Django's built-in admin interface.
• apps.py: A configuration file for the app itself.
• models.py: This is where you will define your application's data models. Each model is a Python class that maps to a database table.
• tests.py: For writing unit and integration tests for your app.
• views.py: This is where you will write the request-handling logic. A view function receives a web request and returns a web response.

Registering the App

As the video emphasized, creating the app is not enough. You must tell your Django project that this new app exists.

Open core/settings.py and find the INSTALLED_APPS list. Add your new app's name to the list:

# core/settings.py

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'portfolio',  # Add this line
]

4. A Note on App Organization

You've created one project and one app. But how should you decide what goes into an app? How many apps should a project have? This is a design question. Given your background in building complex systems, thinking about architectural principles like high cohesion and low coupling early on is beneficial.

The final video clip for today touches on these design considerations.

The key takeaway is that good app design promotes reusability and maintainability. An app should be a focused, self-contained unit of functionality.

Conclusion

Well done! You have successfully created the fundamental structure of a Django application. You've taken a significant step from having an abstract tool (pip install django) to having a concrete, runnable project skeleton.

Key Takeaways:

• A Django project is the main container, while apps are modular, reusable components that provide specific functionality.
• Use django-admin startproject <name> . to create a project in the current directory.
• Use python manage.py startapp <name> to create a new app within the project.
• Crucially, you must register every new app by adding its name to the INSTALLED_APPS list in settings.py.
• The generated files (settings.py, urls.py, models.py, views.py) provide a clear separation of concerns for configuration, routing, data modeling, and request logic.

Preview of the Next Lesson:
So far, our project doesn't do anything. In the next lesson, "Explain the MTV (Model-Template-View) pattern in Django," we will dive into this core architectural pattern. We'll write our first view in portfolio/views.py, connect it to a URL in core/urls.py, and make our server return its first custom HttpResponse. This is where we start bringing the application to life.