
One of the most important things in software development is time. Linting saves so much time. In this post we will learn about how to setup linting for your django projects or python as general. If you have been following this django series, here is the [code](https://github.com/YasinYA/local_book_store) that we wrote so far. Each post will have it's own branch, for this one the branch name is `linting-and-formatting`.

## What is Linting?

According to [Wikipedia](<https://en.wikipedia.org/wiki/Lint(software)>) lint or a linter, is a tool that analyzes source code to flag programming errors, bugs, stylistic errors, and suspicious constructs.

**Simple explanation:** it is a tool that goes through source code with the goal of finding issues that can cause errors or disobey the code style you choose. For instance:

```Python
title = "linting and formatting"
print(titel)
```

Clearly you can see that this program will output error when you try to run it because the variable `"titel"` we are trying to print is not defined. At time you realize the program is not functioning correctly you already lost few seconds! Linters run in the background and can detect these errors and let you know about them without you leaving your code editor.

There are two types of linters:

-   Logical linters : These linters caught the logical bugs like undefined variables as we see above.
-   Stylistic linters: These linters look for stylistic issues like number of characters in a line or indentation.

Every programming language has linters and Python isn't an exception. To name a few of the popular linter in python:

-   Pylint
-   Flake8
-   AutoPep8

In this tutorial we will use [flake8](https://pypi.org/project/flake8/), because it is beginner friendly and has powerful features.

## Setting up Linting

Although linters can be used as CLI tools, it is a pain in the rare to run the linting command every time you want to commit your code to source control or it can be forgotten entirely. To avoid this we will setup our linting process to automatically run when we run the git commit command. We will use [git hooks ](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) and [pre-commit](https://pre-commit.com/) package to achieve this, lets install and setup pre-commit.

```Bash
pipenv install pre-commit
```

In the root project directory create `.pre-commit-config.yaml` a config file which configures the sources where the hooks will be taken from. In our case, `flake8` and `black` which has already been included in pre-commit framework so we just need to specify their ids.

```Yaml
repos:
-   repo: https://github.com/ambv/black
    rev: stable
    hooks:
    - id: black
      language_version: python3.6
-   repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v1.2.3
    hooks:
    - id: flake8
```

Now run below command to initialize pre-commit in your git repo.

```Bash
pre-commit install
```

### Code Formatting: Black

Black is an opinionated tool that formats your code in the best way possible. You can check it's design decisions in this [repo](https://github.com/psf/black). One of the notable formatting decisions is:

-   Line length is 88 characters, not 119 as Django recommends in their contributor [style guide](https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/coding-style/) or 79 as [PEP8](https://www.python.org/dev/peps/pep-0008/).

Good thing, they have an option to overwrite the rules. we just need to create and put our configuration in `pyproject.toml` file as mentioned below and everything is all set.

```Toml
[tool.black]
line-length = 119
include = '\.pyi?$'
exclude = '''
/(
    \.git
    | \.hg
    | \.mypy_cache
    | \.tox
    | \.venv
    | _build
    | buck-out
    | build
    | dist
)/
'''
```

**Note:** If you are not a fan of black, there’s always [autopep8](https://pypi.org/project/autopep8/) a formatter more faithful to PEP8.

### Linting: Flake8

Flake8 is a powerful tool that checks our code’s compliance to PEP8. In order for black to work nicely with flake8, we need to list down some error codes to ignore. Create `.flake8` in the root project directory and put in configuration below:

```
[flake8]
ignore = E203, E266, E501, W503, F403, F401
max-line-length = 119
max-complexity = 18
select = B,C,E,F,W,T4,B9
```

That's it!

Now try to add and commit your code to git. You should see that both black and flake8 are running against your code.

## Conclusion

I hope you enjoyed, If you have any questions, use the comments section below, we will help you. If you liked this post get the word out to your friends and consider joining us. We will notify you for freebies and more posts. [Click here to be part of us](https://teckave.com/subscribe)


Django Series Part 3 - Linting and Code Formatting In Django Project

PART 3 - LINTING AND CODE FORMATTING IN DJANGO PROJECT


## Basics of Markdown

It’s no secret that we’re big fans :revolving_hearts: of Markdown at [Teckave](https://teckave.com/). We write our blog posts entirely in Markdown.

Once you get the hang of Markdown, it’s an incredibly powerful writing tool which will allow you to write rich content for the web far faster than almost any other method. To get to that point, there’s a little bit of a learning curve.

We thought we’d put together a guide to make that curve a little bit shorter, and potentially teach me and you a few super hacks and tricks.

Note, I am learning with you on this journey and to be honest am excited :sparkles: so let's get our hands dirty with markdown :metal:.

### What is Markdown?

Before we get to the nerdy and technical definition of markdown, we both know that sh\*\* is boring :sleepy: let's talk about HTML, the programming language which we can hack NASA with :stuck_out_tongue_winking_eye:.

![Meme](https://pics.me.me/learn-html-to-get-a-job-learn-html-to-hack-41871935.png)

> **Jokes aside markdown is HTML without the tags.**

Now lets introduce Markdown probably.

**Markdown** is a plain text formatting syntax for writers. It allows you to quickly write structured content for the web, and have it seamlessly converted to clean, structured HTML.

Back in 2004, Apple pundit John Gruber came up with the idea after becoming frustrated by writing long, laborious HTML tags to properly format his content. He devised a simple writing system which would make web based documents both easier to write, and easier to read in their raw state.

Here’s a quick example of Markdown in action:

```Markdown
If  [Internet Explorer](https://www.microsoft.com/en-us/download/internet-explorer.aspx)
is brave enough to ask to be your **default browser**,
You are brave enough to ask that *girl* out.
```

becomes

"
If [Internet Explorer](https://www.microsoft.com/en-us/download/internet-explorer.aspx) is brave enough to ask to be your **default browser**, You are brave enough to ask that _girl_ out :smirk:.
"

With just a couple of extra characters, Markdown makes rich document formatting quick and beautiful. Infact this entire post is written in Markdown.

### Basic Markdown Formatting

> Ok! You’re sold :raised_hands:. So how does this work? Let’s Learn together.

Markdown was designed with the explicit intention to be easily readable by humans. You should find that most of the syntax is pretty simple and easy unless you are an alien :scream:.

Below we have specified all the basic elements you’ll use most often:, this will also be our reference for the future because after all we are dumb creatures and we forgot a lot, don't pretend that you ain't dumb :smirk:.

### Headings

Headings in Markdown are any line which is prefixed with the # symbol. The number of hashes indicates the level of the heading. One hash is converted to an header1, two hashes to an header2 and so on. There are 6 levels of headers that you can make use of - but let's be honest here for most writing, you’ll rarely ever need more than 3.

```
# Heading 1
## Heading 2
### Heading 3
```

this becomes

# Heading 1

## Heading 2

### Heading 3

---

### Text

If you want a word to be _italic_, wrap it in asterisks. Making a word **bold** doesn't take that much too, just double the asterisks. bold-italic statements **_John Wick style_** :gun:, use triple asterisks.

```
*italic*
**bold**
***bold-italic***
```

**NOTE: If you prefer, you can also use underscores - they’re completely interchangeable.**

---

### Links

Links can be either inline with the text, or placed at the bottom of the text as references. Link text is enclosed by square brackets `[]`, and for inline links, the link URL is enclosed by parens `()`.

```
[Tekcave](https://teckave.com/)
```

becomes

[Tekcave](https://teckave.com/)

### Lists

Lists are a formatting nightmare in HTML
![Meme](https://media.giphy.com/media/3ofSBoGaRAsrGTbb56/giphy.gif)

but Markdown lists are incredibly easy to manage. For a bullet list, just prefix each like with a `*` and they will be converted to dots.

```
* Milk
* Bread
    * Rice
* Meat
```

becomes

-   Milk :cow:
-   Bread :bread:
    -   Rice :rice:
-   Meat :meat_on_bone:

For nested lists; just indent a line with 4 spaces and it will be nested under the line above. You can also create numbered lists, do exactly the same thing but use numbers instead of the single start
e.g

1. Milk.
2. Bread
3. Meat

### Quotes

When you want to add a quote in Markdown, it’s extremely easy I mean soo easy that you would lough at this, I mean its ridiculous its made with single character `'>'`

![Meme](https://media.giphy.com/media/OK27wINdQS5YQ/giphy.gif)

```
> I want someone to look at me the same I look at my tea
```

> I want someone to look at me the same i look at my tea :cry:

### Images and Gifs

Markdown images and gifs have exactly the same formatting as a link, except they’re prefixed with exclamation mark `'!'`. Another markdown magic:sparkles:

```
![magic](https://media.giphy.com/media/NmerZ36iBkmKk/giphy.gif)
```

becomes

![magic](https://media.giphy.com/media/NmerZ36iBkmKk/giphy.gif)

now lets answer the big question that I think you have in mind :sunglasses:!

### What are the Best Markdown Apps?

Although you can write markdown in any basic text editor and then export it later into HTML you need to preview your document first and Here are some of our three favorite Markdown editors, [Simple Note](https://simplenote.com/), [Visual Studio Code](https://code.visualstudio.com/) and [ Ghost Writer](https://wereturtle.github.io/ghostwriter/)

### Conclusion

“Is that it?” - I hear you ask - “I could just click on a few formatting buttons in most editors and achieve the same thing!”

![magic](https://media.giphy.com/media/9MJgsA8L9VrpgyoALs/giphy.gif)

While most beginner users do indeed find buttons a bit easier to use, advanced writers often write with Markdown and nothing else. Why? The biggest reason is **writing flow.**

Using a traditional writing user interface e.g **_'Microsoft Word'_** you have to pause your writing every few minutes (or sometimes seconds) and reach for the mouse in order to click, highlight, click a formatting button, and then click back to where you left off in order to continue. This process is just dumb, all we want to do is get the words out of our head and onto the screen.

After just a couple of hours with Markdown, we’re certain that your fingers will be flying across the keys as you write your greatest document.

![Lets Start](https://media.giphy.com/media/5zf2M4HgjjWszLd4a5/giphy.gif)

I hope that we enjoyed learning markdown together, and don't forget this is just a basic introductory to markdown.

We will publish an advanced markdown blog post which we will be able to use the big guns of markdown, [**Stay Tuned**](https://teckave.com/subscribe).


BASIC OF MARKDOWN


We talked about what django is and why you should consider it in the [part 1](https://teckave.com/django_series_intro_to_django/) of this tutorial series. In this post we will answer this question "how to setup a django project from scratch?" we will learn about installing django and how to organize a django project.

## Introduction

In this tutorial, I assumed you know that django is a **python web framework**, if you read the previous post you probably do, we also hoped you used **command line** before, if you didn't read up on the commands in the list bellow. We will go through installing django and few other dependencies required to get your project up running.

#### Things to get familiar with

-   **Commands**
    -   cd
    -   ls
    -   rm
    -   mkdir
-   **Concepts**
    -   Modularity
    -   Environment Variables

## Set up

What we will need to setup django project.

-   Python
-   Pipenv
-   Git
-   Database
-   Code Editor

### Python

Django can be used with `python 2` or `python 3`, but I wouldn't recommend `python 2` as it is getting terminated by 2020. We will use `python 3.6.x` for this project.

```bash
$ python -V
Output: Python 3.6.8
```

if your output says `3.6.x` you good to go. If you have an older version of python, there are amazing tutorials on how to install newer version go look it up.

### Pipenv

Pipenv is a packaging tool for Python that solves some common problems associated with the typical workflow. It solves the problem of having two different tools for package installation and virtaulenv. It also solves the pain of maintaining `requirements.txt` file. You can read up on pipenv in this [post](https://realpython.com/pipenv-guide/) or checkout the [docs](https://docs.pipenv.org/en/latest/basics/).

### Git

We will use Git and Github for version control. if you are new to version control systems or git this [post](https://realpython.com/python-git-github-intro/) goes in detail about them.

```bash

$ git --version
Output: git version 2.23.0
```

if you have 1.x or older please install newer version something like 2.x.

### Database

Its rare to see application that doesn't work with some sort of data in this day and age. In this project we will use PostgreSQL as a database. If you don't have postgres installed on your system read this [tutorial](https://www.digitalocean.com/community/tutorials/how-to-install-and-use-postgresql-on-ubuntu-18-04). We will setup the database for this project in a minute.

### Code Editor

You can use whatever editor you want, django doesn't have opinion about that. if you don't have a code editor or you just starting out, I would recommend Sublime text 3.

Now that we have what we need to start the project. lets get started...

## Project Setup

### Project Directory

Every project needs a folder. Let's create one. Navigate to where you put your projects with the `cd` command. then make a directory(folder) with the `mkdir` command.

```bash
$ cd Projects
$ mkdir local_book_store
$ ls
Output: local_book_store
```

If you have other project in that directory you might see them in the list with newly created folder.

### Virtaulenv

Before we install anything lets setup virtualenv for the project. Make sure you are in the project directory.

```bash
$ cd local_book_store
$ pipenv --python 3.6
Output:

Creating a virtualenv for this project…
Pipfile: /home/username/Projects/Blog/local_book_store/Pipfile
Using /usr/bin/python3.6m (3.6.8) to create virtualenv…
⠹ Creating virtual environment...Already using interpreter /usr/bin/python3.6m
Using base prefix '/usr'
New python executable in /home/username/Envs/local_book_store-rkvcCW33/bin/python3.6m
Also creating executable in /home/username/Envs/local_book_store-rkvcCW33/bin/python
Installing setuptools, pip, wheel...
done.
Running virtualenv with interpreter /usr/bin/python3.6m

✔ Successfully created virtual environment!
Virtualenv location: /home/username/Envs/local_book_store-rkvcCW33
Creating a Pipfile for this project…

```

This command will create not only virtualenv but also a file called `Pipfile` which keeps track of the project dependencies.

**Note: this command uses the folder name for virtualenv name**

To activate the virtualenv run this command in project folder where the `Pipfile` is:

```bash

$ pipenv shell

```

### Installing Packages

Now we are finally ready to install `django`, `psycopg2-binary` for postgres database connection, `path-py` for dealing with paths.

```bash

$ pipenv install django path-py psycopg2-binary
```

### Starting Django Project

With django installed now we are ready to ask django to put together a project for us! remember django has so many functionalies built in to it.

```bash

$ django-admin startproject local_book_store
```

Now if we look in to our folder we will see that django created a folder and few python files for us.

```
└── local_book_store
    ├── local_book_store
    │   ├── local_book_store
    │   │   ├── __init__.py
    │   │   ├── settings.py
    │   │   ├── urls.py
    │   │   └── wsgi.py
    │   └── manage.py
    ├── Pipfile
    └── Pipfile.lock
```

Though there is nothing wrong with this structure, but there is always a room for improvement. Let's re-arrange the folder structure to more comfortable way. To do that we need to understand what every file does. `settings.py` as the name describes it is the project settings file, where you keep things like your database, middlewares, manage apps(django apps) in your project, we will consider this settings file as common project file, because settings will be different when we developing the project than when we deploy to production. `urls.py` is where all routing happens, in other words its the file you keep project wide(common) urls. `wsgi.py` its the `WSGI ( Web Server Gateway Interface )` file, we will explore this file more in the deployment section of the series. if you want to read up on it you can start with it's [docs](https://wsgi.readthedocs.io/en/latest/index.html). `manage.py` is a command line utility for administrative task, things like create applilcations, running development server. Finally `__init__.py` is a file required to make Python treat the directories as containing packages. `Pipfile`, `Pipfile.lock` are the files that pipenv created for us.

After fixing up the directory structure now our folder tree should look like this:

```
└── local_book_store
    ├── apps
    ├── __init__.py
    ├── manage.py
    ├── Pipfile
    ├── Pipfile.lock
    ├── settings
    │   ├── common_settings.py
    │   ├── development_settings.py
    │   └── __init__.py
    ├── urls.py
    └── wsgi.py
```

Its more maintainable and easy to navigate now. All of the settings will be in folder. the common file like `urls.py`, `wsgi.py` , `manage.py`, and `Pipfiles` are in the root folder. I created empty `apps` directory that all the apps we create will be under.

**Note: this project directory structure is how we like to structure django projects at Teckave. The way you structure your projects is entirely upto you, but for this tutorial I will stick with this structure.**

### Getting the project running

Out of the box if you go into the folder that django generated and run the server the project will work fine, but since we moved files around we need to fix the code. Before we start doing that, we need to understand how django projects work. The main file in the project is the settings file. We moved and renamed the file so now if we try to run the project there will be an error from django saying "I am confused! I don't know which settings file to use or where to find it". To help django get out of the confusion we need to tell it where and which file to use, we do that by using environment variable called `DJANGO_SETTINGS_MODULE` which django looks for when starting a project. To set this env variable run:

```bash

$ export DJANGO_SETTINGS_MODULE='settings.development_settings'

```

with this command we are telling django to look for a settings folder inside our project directory and in that it can find the development settings we will write in a moment.

Lets start with `settings/common_settings.py`:

```python
"""
For more information on this file, see
https://docs.djangoproject.com/en/2.2/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/2.2/ref/settings/
"""

import os
import sys
from path import Path as path


# This is creating the project path
PROJECT_PATH = path(__file__).abspath().realpath().dirname().parent
# This is creating django apps path
APPS_PATH = PROJECT_PATH / "apps"

# Adding our project and apps path to the system path
sys.path.append(PROJECT_PATH)
sys.path.append(APPS_PATH)


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/2.2/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'pewk#1qzkxnd9xh+_eoaj@jy&znvpv&9lfk#gw-h2q*%azy=mp'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

ALLOWED_HOSTS = []


# Application definition
# This tuple will contain built in django apps
# and the third party apps we will install
EXTERNAL_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
)

# The apps we create for the project
INTERNAL_APPS = ()

MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

# We change this, to reflect on where we moved the url.py file.
ROOT_URLCONF = 'urls'

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

# We change this, to reflect on where we moved the wsgi.py file.
WSGI_APPLICATION = 'wsgi.application'


# Password validation
# https://docs.djangoproject.com/en/2.2/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/2.2/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True
```

Now it's time for the development settings. In the `settings/development_settings.py` put this code:

```python
from .common_settings import *

# For better debugging
# This is only for development
DEBUG = True

# Database
# You can change the name, user, and password if you want to
# https://docs.djangoproject.com/en/2.2/ref/settings/#databases
DATABASES = {
    "default": {
        "ENGINE": "django.db.backends.postgresql_psycopg2",
        "NAME": "local_book_store",
        "USER": "localbookstoreuser",
        "PASSWORD": '123',
        "HOST": "localhost",
        "PORT": "",
    }
}

# These are the third party apps that
# we need in the development process
DEVELOPMENT_APPS = ()

# This is the variable that django looks for
# to know about the apps that the project uses.
INSTALLED_APPS = EXTERNAL_APPS + DEVELOPMENT_APPS + INTERNAL_APPS


# Media files / the files that we upload
MEDIA_ROOT = os.path.join(PROJECT_PATH, "media")
MEDIA_URL = "/media/"

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/2.2/howto/static-files/
STATIC_URL = "/static/"
STATICFILES_DIRS = [os.path.join(PROJECT_PATH, "static")]
```

To learn more about django settings head over to the [docs](https://docs.djangoproject.com/en/2.2/topics/settings/).

Fixing up the `manage.py` file.

```python
#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys


def main():
    # See, Django is protecting us, if we forget to the set
    # the env variable it will use this default settings.
    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'settings.developemt_settings')
    from django.core.management import execute_from_command_line
    execute_from_command_line(sys.argv)


if __name__ == '__main__':
    main()
```

We also need to fix up `wsgi.py` file.

```python
"""
WSGI config for local_book_store project.

It exposes the WSGI callable as a module-level variable named ``application``.

For more information on this file, see
https://docs.djangoproject.com/en/2.2/howto/deployment/wsgi/
"""

import os

from django.core.wsgi import get_wsgi_application

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'settings.developemt_settings')

application = get_wsgi_application()
```

Now that we fix the code, it is time to setup the database.

### Database Setup

Postgres provides a terminal tool called [`psql`](https://www.postgresql.org/docs/9.3/app-psql.html) that will facilitate the database interactions for us.

```bash
$ sudo -u postgres psql
```

This will ask you to type your password if you set it in the installation process. Once you are in the shell run these commands to create the db.

```sql
CREATE DATABASE local_book_store;
CREATE USER localbookstoreuser WITH PASSWORD '123';
GRANT ALL ON DATABASE local_book_store TO localbookstoreuser;
\q
```

Django migrations help us sync the database with the schema we already have. Lets ask django to setup the db for us.

```bash

$ python manage.py migrate
```

If you forgot to set the `DJANGO_SETTINGS_MODULE` you will get an error so make sure its set.
Django comes with administrative area but doesn't have a default user so we need to create it. `manage.py` will help us do that:

```bash
$ python manage.py createsuperuser
```

this command will ask you info about the user. so fill it up.

### Starting the project

Finally, we can start up our development server!

```bash
$ python manage.py runserver
Output:
Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
September 20, 2019 - 19:21:45
Django version 2.2.5, using settings 'settings.development_settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
```

If you got this output you are good to go. Head over to your web browser and visit `http://127.0.0.1:8000/`. You should see the django welcome page.

Congrats! you just setup and started django project! At this point you should award yourself with cup of really good coffee.

If you have any questions, use the comments section below, we will help you. If you liked this post spread the knowledge and consider joining us. We will notify you for freebies and more posts. [Click here to be part of us](https://teckave.com/subscribe)


Django Series Part 2 - Project and development Environment Setup

PART 2 - PROJECT & ENVIRONMENT SETUP


# Introduction

This tutorial series is about Django web framework fundamentals. We are going to build a bookstore application and explore all the basics of Django from installation to project and development environment setup best practices, we also gonna learn about deployment process.

Althought there are many post like this one, the reason I created this series is I want to do something different. I want to create a tutorial that is easy to follow, informative and shows the process of creating web applications. I hope you enjoy reading it.

Before we start...

The way to get better at something is to do more of it, I strongly recommend you write the code and use this tutorial as a guide. **Don't copy and paste**

### About Django

According to the django [website](https://www.djangoproject.com), "django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design". Web framework is a collection of components that provide a fast and easy way to write web applications. Some of the busiest websites proved django can be used in any case. Whether it's building community-based apps like Disqus, that has millions of users, or handling **95 million** photos and videos per day like Instagram, or stream music as Spotify does.

The development of Django is supported by the [Django Software Foundation](https://www.djangoproject.com/foundation/). Companies like JetBrains and Instagram sponsor it too.

### So Why Django

Django is time tested, it's been around more than a decade that make it mature and reliable. Django is written in python and it uses python as a programming language which means that you can take advantage of python's huge open source libraries. The [Python Package Index](https://pypi.org/) has more than **194k** packages as I am writing this post. Whatever you are solving chances are, somebody else already solved it. Django is one most popular web frameworks in python world. It's probably the most complete too. It offers a lot of features out of the box, things like ORM, templating engine, form processing, session management and caching. Django also comes with an admin interface and authentication system. There is even built-in [Geographic Information System](https://docs.djangoproject.com/en/2.2/ref/contrib/gis/) (GIS) framework that I recently discovered which is pretty cool!

### Core Concepts

Django's main target is to facilitate the development of complex dynamic applications. Its philosophy is to make writing decoupled and organized sources code very easy. Django is **MVC** framework. It encourages to follow best practices of web development and programming as general. Django has two main concepts:

-   **Project**: is the web application.
-   **App**: Is a reusable python package that does a specific job for the project.

#### Project

Project is the application you are building, in other word the larger project. There can only be one project in a django web application. A project contains configuration files and single or multiple apps.

#### App

App is a reusable small package, that represents a specific part of the larger project. For example, our bookstore web application might have an app for `books`, one for the `authors` and another one for `payments` to charge customer. It's Important to know that an **App** can't be run without a **Project**.

At first it might be hard to know what is an app and what is not, as we dive deeper we will talk about these concepts more in-depth and you will get your head wrapped around it. Don't worry now!

If you read this far you are Amazing! If you have any questions, use the comments section below, we will help you.
If you liked this post spread the knowledge and consider joining us to get updates about freebies and more posts. [Click here to be part of us](https://teckave.com/subscribe)


Django Series Part 1 - Introduction to Django and it's Core concepts

PART 1 - INTRO TO DJANGO


# Why Tech is so Important

In this modern age, it is impossible to not bring technology when talking about business. We can think of infinite reasons which make technology so crucial for the overall success of any business. I can dare to say it has a bigger impact in this information age than steam had on the industrial revolution. It drives innovation and innovation leads businesses to success.

In 2019, there are **4.39 billion** Internet users and the numbers are projected to continue with the exponential growth they’ve been undergoing in the past three decades. Therefore, technology is the only means that you can reach more than half of living people and change their lives or solve the problems they face.

Technology has entirely changed the way business is done. Today what companies around the world figure out first is how they can build smart technology based solutions.

Below are some of the main benefits of technology for businesses and individuals.

### 1. Cost Efficiency

In business operations cost and time are directly proportional. If it takes less time it will cost less. By taking advantage of technology you can gain benefits such as ease of sharing and storing information or automating repetitive tasks, that will ensure productivity increase. In fact business can now survive without physical offices and less manpower!

### 2. Flexibility

Every customer has needs, some might like to shop at midnight others at normal hours and the store can't be open 24/7 without extra cost. Great employees might prefer to work from home which is common these days. Flexibility is really important key here and businesses can no longer avoid using technology to make their clients and employees statisfied.

### 3. Scalability

When business explodes and suddenly it has to serve millions or even billions of people around the world, workload and costs will get out of hand pretty quickly. In that situation only technology can save the day. Leveraging tools like chatbots, CRM (Customer Relationship Management) systems and Automation will be inevitable, save so much time and resources.

### 4. Growth

Making the best possible decisions help businesses grow exponentially. This art depends on accurately analyzing business data and predicting the future accordingly, any mistake can lead to unfortunate results. Without technology behind the wheels it's obvious that the business will be taking down the wrong path. Technology provides the infrastructure and proper tools to make your analysis and predictions more reliable. It takes away the human error and other error prone variables out of this equation and what you get is pure rapid growth.

Thanks for reading, lets know your thoughts in the comments below.

If you liked this post consider subscribing to our list and get updates about freebies and great content. [Click here to subscribe](https://teckave.com/subscribe)


IMPORTANCE OF TECH IN BUSINESS


## Who are we

Teckave is a design and development company. We create beautiful, modern and carefully crafted designs that push costumers to engage with your brand. We also help in building and bringing those designs to life. Our mission is to provide high quality, affordable solutions to businesses and change people’s mindset about technology. We are based in Hargeisa the capital city of Somaliland

## Why did we start Teckave?

Technology is personal in this era and it has become one of the basic needs, right there with the water and food. Here in Somaliland businesses face numerous challenges when it comes to technology in general and with their online presence in particular. Most of the tech solutions are high priced and low in quality. Business owners always struggle finding the right services for their product. Most of the tech companies put less importance on the product as long as they are getting paid. This crippled innovation, entrepreneurship and the economy of the country. As any other problem, this one has a solution! After a long careful observation of the issue, we decided to do something about it. We started Teckave!

## How do we bring solutions

To solve this, we tried a number of different methods, but then it hit us, the problem wasn't about numbers, or science. It was about the mindset, what people believe tech services should be. We had a new task which was bigger than anything before, How do we change the mindset? We figured the only way you can change a mindset is to help people realize that a change is needed, so we decided to show the people their missing rights and the lost opportunities.

We want to show that tech business is much more than just making money. Deep connection, empathy and care is necessary. Our work affects lives and we only want to make those lives better, thats why we care so much.

Of-course changing the mindset of whole country is a huge task, but if we don't do it no one will do for us. Keep in mind change also doesn't happen in one night. With the help of hard work and determination together as a nation can make it happen.

## Conclusion

Thank you so much for reading this far. We hope you would join this vision and save the country with us. Let us know what you think in the comments below. If you want to know more about our services, please visit [**here**](https://teckave.com), and don't miss our upcoming deals and programs, subscribe by clicking [**here**](http://teckave.com/subscribe).


Tutorials and Tech Reviews

Recent Posts

PART 3 - LINTING AND CODE FORMATTING IN DJANGO PROJECT

Yasin Yusuf

BASIC OF MARKDOWN

Abdirahman Mohamed

PART 2 - PROJECT & ENVIRONMENT SETUP

Yasin Yusuf

PART 1 - INTRO TO DJANGO

Yasin Yusuf

IMPORTANCE OF TECH IN BUSINESS

Yasin Yusuf

WHAT CAUSED TECKAVE

Yasin Yusuf