One of the things that's really incredible about channels

is that from the point of view of developing your Django project,

it operates just like any other pluggable Django app.

The author of channels, Andrew Godwin, worked really hard to

find abstractions that would feel familiar to Django developers, and

that would play nicely with the rest of the Django ecosystem.

Eventually, maybe even by the time you're watching this workshop,

channels will be integrated into the core of Django.

And then instead of installing it separately,

you'll just use it any time that you need it.

For now though, we still need to install channels the way that we would normally

install any other package.

So through pip or in my case through PyCharm.

Now you can check out a GitHub repository with all of the code for this workshop.

I'll have a link to that repository along with a note on how to check out

the channel's initial tag.

So you can code along with me in the teacher's note.

On your own computer you'll probably want to install Django and

channels into a virtual environment by using pip.

Since I'm using Pycharm,

however, my installation process is a little bit different.

So for me I go to the project and the project interpreter and

I click the little plus sign and I choose Django.

Now I'm in a specified version, 1.10.3.

You can use 1.10.4 or whatever version you want to use.

I'm gonna install that package.

And then I also need to install channels.

Now, you'll do this with pip install channels if you're using

a virtual environment.

I'm going to do it, again, through here, though.

And I'm going to notice that this is version 0.17.3.

I'm not gonna necessarily specify a version here because, since channels is

still in development, you probably want to use the newest one at any given time so

that you know you have the newest version of channels.

And then one thing I definitely want to remember to do,

is to add channels to my requirements .txt.

So that was 0.17.3 and I will save that.

Now we have channel installed, we need to configure our project to use it.

In the settings.py for the project,

we're going to add channels to our installed Apps.

So I'm gonna add it right here above my votes app.

And then down at the bottom of the settings file, really anywhere but

I like to add this at the bottom, we need to add a new set of settings.

And this is called CHANNEL_LAYERS.

It's a dictionary and

the default key is also a dictionary

which has two keys BACKEND and ROUTING.

So back end is gonna be set to A-S-G-I-R-E-F,

asgiref.inmemory.channellayer.

And routing is going to be set to djangocity.routing.channel routing.

Now this setting is new, you've likely never seen this before,

so it might need a little bit more explaining.

Channels operates on an event driven context.

Events can be messages that you send to your app to various pieces of channels

code or they could be client started events like HTTP requests or

WebSocket client connections.

Channels needs a way of keeping track of events and communicating events

between different pieces of code and it uses a channels layer to do so.

Think of a layer as a messenger between different pieces of code.

Channels ships with some built in layers and

the one that we're using in this setting is the in memory layer.

That layer will keep references and past messages inside of your system's memory.

This layer is fine for development but shouldn't be used in production,

because it can lead to memory leaks and degraded performance.

We'll talk about some other options for

this when we talk about deploying our channel's project.

The last piece of information we need is the channel's routing,

which is referenced by the last line in the channel layers block.

Channels routes are somewhat like Django's URL patterns, and live in a similar place.

Here in the Django City app, the directory that holds our URLs up high,

I'm going to add a new file that's named routing.py.

And yeah, go ahead and add that to version control.

Now this file is going to hold our routes.

So first I'm going to import from channels.routing the route function.

And then I'm gonna make a new list here named channel_routing,

much like we would have a list of url patterns.

So for now that's it.

That's all I need to do.

And I can run the server to make sure that things are still working.

So I can do run server and

we see that we get this busy loop synchronous mode on channel layer.

That tells us that channels are registered.

And if I refresh this page, everything still works.

So our project is now running with channels.

We're ready to start serving WebSockets clients.

In the next video will add some code to our project that will respond

when it receives WebSocket events.