Let's connect your View (page) to app URL.

Open the created `urls.py` file inside the app folder (in our case `new_app` folder).  
*It's a new file, so it will be empty.*

Create the `app_name` and `urlpatterns` variables:
```python
from django.urls import path


app_name = 'NewApp'

urlpatterns = [
    
]
```

In Django, the `app_name` variable is used to specify the application namespace for URL names within a Django app. It is defined in the `urls.py` file of the app. Here's a description of the `app_name` variable:

- The `app_name` variable is a string that represents the namespace of the Django app.
- It is used to create a unique identifier for the app's URLs to avoid naming conflicts with URLs from other apps in the project.
- By setting the `app_name`, you can refer to specific URL patterns using the app's namespace in the Django Tamplate Language (should be described later).
- The `app_name` should be unique and preferably descriptive, reflecting the purpose or name of the app.

We have the implemented `hello_world_view` in `views.py` file:
```python
from django.http import HttpResponse
from django.shortcuts import render

# Create your views here.

def hello_world_view(request):
    return HttpResponse("<h1>Hello, world!</h1>")

```

Import this view to the `urls.py` and add path to `urlpatterns`:
```python
urlpatterns = [
    path('hello', hello_world_view, name='hello-world'),
]
```

Now we have access to this page via URL:
```
http://127.0.0.1:7000/app1/hello
```

If you want to use the `app1` as endpoint URL, you can write the empty string into `urlpatterns`:
```python
urlpatterns = [
    path('', hello_world_view, name='hello-world'),
]
```

Now, the access to this page provided by URL:
```
http://127.0.0.1:7000/app1/
```

At this point, our View is connected, and we can safely modify it:
```python
def hello_world_view(request):
    header = "<h1>Hello, world!</h1>"
    paragraph = "<p>Go to the next chapter!</p>"
    return HttpResponse(header + paragraph)
```

The Django Framework is the best choice to start learning Backend Development using Python! Here you will dive into the Backend, learn how to handle HTTP requests, pass and extract data, and create HTML pages using Templates. In particular, you will learn how to use Python to interact with a database in a very convenient way without using SQL.

This section provides an introduction to Django and its key concepts. It covers the explanation of Django as a web framework, the MVT architectural pattern it follows, and the steps to initialize a new project using Django. The section also includes instructions on running the server.

If you are ready to write your first HTML page on Django - now is the time. Here you can learn how to respond to web requests using the Python programming language.

Do you think that building a database using Python is not possible? It's not true! Let's start to do it with Django!

If you already know how to build a database, then it's time to manipulate data from it. Django ORM is a tool that allows you to work with data from a database. Let's take a look at it, shall we?

The HTTP response as a string doesn't look good. It is worth correcting this by using DTL technology, which allows you to dynamically generate beautiful HTML pages and return them to the user.

You can learn how to answer requests in the previous sections but how to transfer information and process it? Passing data via HTTP request and retrieving is easy. You just have to figure it out, you can find help here.

Django: First Dive

Connect View to URL