Table of Contents
The excitement of learning Python programming language became even better after the introduction of Django. It is a Python framework that does not know how to disappoint even if it tried. This high-level Python web framework can be described in three traits:
- rapid development
- clean code
- pragmatic design
An honest opinion would classify Django as something ahead of its time. It’s simple in design and dynamic in the functionality it offers. The Django Software Foundation is the maintainer of this open-source Python-based web framework. Django follows a model-templates-views (MTV) architectural pattern approach. MTV, in simple words, is a software design pattern.
As the name suggests, the design pattern carries three significant software development components. They are the Model, the View, and the Template. The Model component is responsible for the management of data that interacts with the app. The Model component creates a means to create and manage the database used to store user data. The Template model is the engine that completely powers the User Interface. It is responsible for the visual components linked with the software application data and logic. It is the visual depiction of the magic tricks performed behind closed curtains when the app data and app logic meet.
The Model component and the Template component can only have a viable connection if the View component completes their love triangle. The View component is the app logic or business logic. Therefore, understanding a View is straightforward. It will access and interact with the Model’s data by creating the needed logic from the given data set. The logic can be something like a User Login function or a User Registration function. Data will be referenced from the Model and manipulated or created and stored in the Model, which infers to a connected database.
After the view component is done interacting with the database data through the Model component, it will render the stipulated logic or functionality on the Template component. Therefore, we can consider of the View component as a timely bridge between the Model component and the Template component.
Understanding Django
An example of an already pre-configured Template component is the Django Admin Interface. Your first interaction with the Django framework empowered you to create a superuser before you even started building your app. You were prompted from the terminal to set up a superuser’s username, password, and email address. You use these configured credentials to access the Admin Interface side of your Django project. Some pre-configurations took place here. You created your credential data, which Django used to generate some in-built View logic. It enabled you log-in to the Admin side of Django and work with the default Django Admin features. This is the perfect example of an already existing Model-View-Template approach.
Django is keen on adhering to the MVC (Model View Controller) convention that many frameworks follow. However, the framework is keen on working with its own control rules. Since the control you need when dealing with your Django apps is not isolated, Django is sometimes called an MVT application with the View component bridging the Model component and Template component of your apps.
A graphical layout of how Django adheres to an MTV-based functional and design architecture is depicted below:
We can summarize this image depiction as follows. First, let us assume you have a complete Django app. When a user initiates the first interaction instance with this app, he or she will send the intended request to Django. Django receives the request and notes down the resource being asked by the user. The only way Django can check the availability of the requested resource is through URL (Uniform Resource Locator). Django URLs are mapped to different Functions or Class Views. Therefore, a URL will go through the defined Classes and Function Views and see if it matches with the specified resource. If there is no match, Django will return the appropriate error response. However, if there is a resource match, View will interact with the target Model, manipulate the needed data, and render a template for display. Therefore, the resource call through Django URL ends with a response template regardless of whether the requested resource was available.
Now that we have had a quick tour into the intestines of Django, it is time for potential Django developers like you to have a taste of the much-awaited dessert. Being an excited Django framework beginner is different from being a progressive Django framework beginner. Excitement is a charm every developer should have as it propels them to create the best version of apps they can imagine. However, an excited explorer is bound to get lost in the woods. The same logic applies here. The only way to proficiently grow in Django is to take a progressive path. This path depends on the fundamental ground rules you set before you start your developer’s journey. It is through adherence to the best Django coding practices.
Experienced Django developers have already been on this path. They already made and learned from the Django development mistakes we could have made. They have a polished Django manual for best app development practices. We, therefore, need to learn from these tips. After filtering through their Django developers’ manuals, we discovered that the following tips would take you far in your Django development career.
1. Make Use of the Django Unit Test
Since this article assumes that you are a baby in Django, you have the permeability of adhering to new learning curves. You are still excited about code, which makes you the better candidate for venturing into Django Unit Test. The Django Unit Test allows you to seek a Test-Driven approach when you start developing your apps. This approach basically means that you write a test for each code function you want to implement before bringing the actual code to life. It allows you to have an in-depth familiarity with the code segments you are creating. Through unit testing, you will be able to refactor your code, making it clean and precise. It will help you eliminate unnecessary code lines or blocks that don’t add any value to your app’s existence.
A unit test is also the perfect troubleshooter for your linked code modules. As your project grows, your code blocks or segments will also grow or increase. Therefore, you will find it easier to manage your code if you create separate code modules and link them through Python’s import functionality. But before you hack this approach, your journey as a developer will take you to the depths of having to deal with broken codes. The real nightmare starts when you do not know nor understand the code segment causing problems. A practical solution will demand that you study every segment of the code you created line by line. It will be time-consuming, and the erroneous logic you are trying to fix might still hide from you. However, implementing a Unit Test through a Test-Driven project development approach will pinpoint the exact line of code where things started to fall apart.
2. Your Reference Code Should be Free of the Project Name
In Django, one of the first steps to take before you begin your app development journey is to set up the project name that will host the many apps you will need to create. You will find yourself using a simple terminal command like:
$ django-admin startproject project_name
Afterwards, you will also need to create an app to be hosted by this initialized Django project.
$ python manage.py startapp app_name
The created app will automatically generate the Models, Views, and Admin files, among others, you will need to develop your app. The hierarchy of the directory structure representing this Django project will be of a similar fashion:
project_name → app_name → Views or Models or Admin… files access.
Therefore, if we want to access an Author field from the created app_name’s model, we would do the following:
from project_name.app_name.models import Author
Django uses this code reference fashion or approach to access the different file and directory layers of an existing project. However, the above reference code approach from the project_name is tightly coupled and will hinder your Django project’s flexibility. A recommended code reference approach should start with app_name.
from app_name.models import Author
This approach makes it easier to reuse your Django applications. A good real-world practical instance is when you successfully build a flexible user registration app under a different project name. You might be working on a new project and do not want to re-invent the user registration app’s wheels. Therefore, if your code reference starts from the app name and not the project name, you can easily copy the app to your new project and only make light adjustments for its configuration to be up to scale and adaptable. However, a code reference starting with the project name will force you to rename each instance the old project name occurs on your new project environment before every component of your new project works correctly.
3. Avoid Hardcoding TEMPLATE_DIRS, STATIC_ROOT, and MEDIA_ROOT
You will find these aspects of your Django project configuration in the settings.py file of the project name directory. The TEMPLATE_DIRS aspect of the Django project configuration is to cater to your template files’ storage destination. These are mainly the HTML files needed to create the UI which Django Views will render. They can also be a text file or a document. Django will automatically find the templates you are using and render them if you stored them inside a created templates folder in your app directory. STATIC_ROOT points to the storage of static files like CSS and Javascript needed to make your app more exciting. MEDIA_ROOT points to the storage destination of media files or images you might need to upload or serve while using your app. MEDIA_ROOT and STATIC_ROOT only need to adhere to the following configurations on your settings.py project file.
STATIC_URL = '/static/' STATIC_ROOT = os.path.join(BASE_DIR, 'static') MEDIA_URL = '/media/' MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
These configurations will create the static and media folders inside your Django project directory for storing your static and media files. Trying to tamper with these configurations will create more problems when your app is ready for a production environment. You might consider your app is broken when it is just a minor project configuration tweak.
4. Make Use of Django’s Debugger Tool
When you launch your first Django project on a development environment, the development server will run on your machine’s terminal or command line. However, it’s more than just a server to power up your project. Since Django is a simplified architecture of Python, the code interpreter rules still apply. Every code change you make while the development server is running will automatically take effect without restarting the server. Therefore, when something does not seem to add up, take a look at the development server screen display, and you will be able to troubleshoot and resolve the issue that caused your running project to break. It’s a priceless tool for a new developer and will save you from much confusion or assumptions that might suffocate your interest in Django.
5. Serve Your Media Files Separately
When you are in a development environment, you will comfortably serve your media files since you are still testing whether every component of your app is working correctly. However, when you serve your files in a production environment, your app logic needs to have some aspect of efficiency. It cannot occur if you are only using one server to serve all the project files. Serving media files with the same web server instance will kill the performance of your web app. A separate server instance like Gunicorn can comfortably handle your static files without interfering with the overall performance of the webserver you have in place. Amazon S3 is another affordable server alternative that can save you from this predicament.
6. Normalize Using the Django Admin for Seamless App Administration
By default, Django provides you with a backend logic for managing the apps and users you create. The user authentication system from Django admin is thorough enough such that you do not need to create an app for reinventing this wheel. It is easy to set up and offers an extra layer of user authentication and authorization. You get to decide which user has authorized access, the level of authorized access, and permitted tasks. Moreover, since Django is loosely coupled, no component is fixed. The Django documentation provides a way of using the Django Admin code logic on your app’s frontend. Therefore, you have more time perfecting your app’s User Interface while worrying less about the perfect user authentication and authorization approach.
7. Minimize Integrating the Business Logic Code on Your Django Views
This tip goes against many Django coding conventions highlighted in ebooks and tutorials forums. Moreover, the MVT in Django has V as the View logic, which determines how your app should behave. However, an elite developer’s approach would be to lessen the code logic in the views.py file and place it in a helper file or module referenced back to the Views file. It will make your logic code more organized. Moreover, you will easily reuse a business logic code without having to collect code fragments from the main Views file. This approach alternatively makes testing your code through Unit Testing more efficient.
8. Your Debug Setting Should be False in a Production Environment
Once you have thoroughly tested your Django app and adheres to the needed coding conventions and best practices, the next exciting step is to have it deployed on a production server. However, we might be carried away by the excitement and anticipation of having our first Django app go live that we forget one important configuration info. We are familiar with how Django’s development server helps us breakdown and troubleshoot the faults in our project code. Because of the Debug configuration in the settings.py project file that is by default set to True. Going to a production environment with this setting still True can compromise your app’s integrity, and an advanced malicious user can see it as an opportunity to exploit the weaknesses that might be on our app.
9. Keep Pinax in Mind
When you consider of the advantages Django has to offer; code reuse is the biggest one of them all. Therefore, you do not have to create a code segment that already exists. Pinax brings this dream to reality. The platform offers direct code modules related to email verification, OpenID, etc. The code spoils are yours to choose from.
10. Start with Flask
The only difference between Django and Flask Python framework is that Django is battery-included and Flask is not. Django gives you a starting advantage in app development because you already have a defined director structure and a Django Admin in place. With Flask, you have to start from the ground up as you build your app. If you start your Python journey with Flask, you will fully understand all the application logic of Python. Therefore, when you later upgrade to Django, everything will seem like child’s play.
Final Note
There is no limit to the number of tips you can get to enable you to become a better Django developer. The Django documentation and numerous forums will help build our developer’s confidence. However, there are significant tips which you have no choice but to adhere to like the ones stated above. They will make your Django development journey less bumpy and more exciting.
Source: https://www.codeunderscored.com/10-tips-for-beginners-getting-started-with-django/
