[MUSIC]

Hi everyone, I'm Kenneth, your friendly treehouse Django teacher.

Today, I want to talk to you about a new and

potentially life-changing feature that's coming to Django named channels.

As you're already aware, Django provides an incredible framework for

building Python web applications.

It has, however,

long been limited in the kinds of web applications it can support natively.

Specifically Django has always had trouble supporting more realtime web applications.

Powered by WebSockets.

Those kinds of applications have just never been a great fit.

Until now that is.

The channel's package provides native WebSocket support Django, and

his developers make real time WebSockets applications, using the tools and

ideas there are to use to from Django.

To understand what channels is doing and why it's such a revolutionary change for

Django we need to understand a bit more about the technology underneath.

When you visit a website like teamtreehouse.com our

computer is being asked by your browser to open a connection to the server

hosting teamtreehouse.com and then ask for some data.

The server hosting teamtreehouse.com prepares the data like,

say the web page for this course and sends it back to your computer.

Your computer receives the data and

closes the connection to the server that's hosting teamtreehouse.com.

I'm glossing over a lot of the specifics because they are required to understand

web sockets and Django channels, but a handy abstraction, if you're old enough to

be doing this is calling an airline on the telephone for a flight status update.

You dial the airline.

They pick up.

You request to find information.

They respond with that information and end the call.

This one request one response cycle is how websites have operated for

most of the life of the Internet.

And the sub Django operates by default.

The views you write, whether they be function based views or

class based views, take in a request object and return a response object.

If you've progressed to the point where you're writing Django middleware

you might have an even deeper visualization of this in your head

as you'll know that requests move down the middleware stack.

And responses move up it until they return to the client requesting the data.

Django middleware until very recently, specified process request and

process response functions that made this explicit.

Given how tightly coupled Django is to the request response cycle,

channels is even more exciting because web sockets change the underlying structure

of the request response model.

Going back to your telephone analogy if the traditional request response model is

calling up the airline requesting information, getting information back and

then ending the call WebSockets is calling up the airline, and

then leaving the line open forever.

You can ask the airline for information, which they'll give you, but they can also

let you know when things change, without you asking about those changes each time.

This is the underlying power of WebSockets.

The client, in our case the browser, opens a connection to the server, and

leaves it open.

The client can pass information to the server.

Or request information like always,

but the server can also send information to the client without prompting.

If you've developed web applications where the data updates regularly,

you can see what a big idea this is.

The client can now potentially only load the site once.

And only load the site's assets.

The JavaScript, CSS, images, etc., once.

Once the website connection is opened the server can update the client whenever

the information changes.

This ability to keep connections open responding to events and sending messages

to the connected clients, isn't possible out of the box with vanilla Django.

Channels works with Django in a very Django way and

requires fairly minimal code changes for all of the functionality that it's adding.

Using the channels package and the related tools, Django gains the ability to be

event driven rather than bound to their request response cycle.

And as a result can now handle the always connected nature of websites.

We'll talk more about what channels is going to do for us in the next video,

where I'll show you the dashboard are we building with channels.