Heads up! To view this whole video, sign in with your Treehouse account or enroll in your free 7-day trial. Sign In Enroll
Well done!
You have completed Treehouse Festival June 2021!
You have completed Treehouse Festival June 2021!
Preview
Building a ToDo app with React & Django with Reggie Williams
66:14 with TreehouseA walk through building a Full Stack application using Python & JavaScript. You’ll learn how to build a todo application using frameworks built for speed.
This video doesn't have any notes.
Related Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign upRelated Discussions
Have questions about this video? Start a discussion with the community and Treehouse staff.
Sign up
[MUSIC]
0:00
All right, I think I'll go ahead and
get started here.
0:07
Again, thank you all for joining.
0:13
Welcome everyone.
0:15
Welcome to the third Treehouse Festival.
0:15
And my first presentation at one of these,
so thank Liz for inviting me.
0:18
I'm Reggie,
I'm an instructor and developer,
0:24
I'm an instructor here at Treehouse.
0:26
And today, if you haven't
already guessed from the title,
0:29
we'll learn about building a to-do
app with Django and React.
0:31
We'll be reading some code,
writing code, practicing some tools, and
0:35
maybe learning some things for
the first time.
0:39
So if you want to, if you could just,
are you a Pythonista?
0:42
Are you a JavaScript developer?
0:47
Are you just starting out?
0:49
If you can answer that in the chat we'll
have something for everyone here today.
0:51
If you're just a,
if you're a Pythonista, awesome or hot.
0:56
Let's see, Python, nice.
1:01
I started with JavaScript myself and
I'm newer to Python, but
1:05
in love with it already.
1:08
Liz is going to be,
you're a great JavaScripter.
1:12
Just a little bit, Professor T.
1:17
So I see we have some mixed results here,
a little bit of both and
1:20
that's awesome cuz we have something for
everyone today.
1:24
Let's see, before we start, this is the
most important thing to remember today or
1:30
these are some of the most
important things to remember.
1:35
Don't worry about
understanding all the syntax.
1:40
We're really focused on figuring out what
we want to do and how we want to do it.
1:44
And then how we want to do it
will come a little second.
1:50
And you don't need to focus so much about
the syntax, you can always go back and
1:53
learn that.
1:57
Every programmer really boiled
down essentially to task,
1:57
a set of tasks that you want to
accomplish and getting those done.
2:01
And we'll work on figuring
out what those tasks are,
2:06
and then we'll complete
them as we go along.
2:08
I'd also say to ask questions,
you can ask them in the chat.
2:12
We have our awesome Treehouse staff, some
developers and instructors in that chat.
2:16
As you've seen in the Treehouse Community,
everyone attending,
2:21
feel free to answer questions
as they come up to.
2:24
And then at the end we'll have some
time to answer some questions as well.
2:28
All right, so today we'll talk about
what full stack development is,
2:34
especially if you're just starting
out this might be more helpful.
2:37
For some of you, it might be review.
2:41
Yeah, don't worry if you have no
idea how to use any of these things.
2:46
If you're starting out
this will be helpful.
2:51
I think it's really helpful to learn
about these things like frameworks.
2:54
Once you've built that base foundational
knowledge and understand the language
2:57
a bit, you can use these to speed up
the process and do things faster.
3:01
So again, you always have time to go back.
3:05
And we have plenty of courses on
almost all the subjects taught here,
3:07
and I'll make sure to put something
out on those things that we don't.
3:11
But we have Django, Python,
JavaScript already.
3:16
We don't have one of the tools that
we're using, Django Rest framework, but
3:20
happy to create a blog about that one,
I've had some fun using it.
3:24
So I'll talk about some of the terms,
again,
3:28
too that may be unfamiliar if you're just
starting out before we get into code.
3:31
So we'll talk about first about
what full stack development is, and
3:39
why it reminds me of both peanut
butter and jelly and a puppet show.
3:43
Talk about why people might use different
languages for different projects, and
3:46
also what libraries and frameworks are.
3:51
Before we write code there's a very
important step that we have complete every
3:53
time we write code or
before we write code.
3:58
I mean you can skip it but
it makes things a lot harder.
4:00
From there, we'll jump into writing
some code, take a short break,
4:05
and finish up our code before our Q&A.
4:10
So full stack development,
if you're coming from the JavaScript side,
4:17
you may be familiar with
HTML CSS working with React.
4:21
If you're coming from the Python side,
you're a Pythonista,
4:25
you may be familiar with data and
managing and analyzing data.
4:30
Full stack is a combination
of both those things.
4:34
Front end is that visual,
that web page that you see,
4:38
that thing that you can interact with.
4:41
Or if you're using a screen reader, this
the thing that you're interacting with,
4:43
whatever form of interaction
you're having with that.
4:48
The back end is typically where
the magic happens, I like to say.
4:51
That's where all the data is controlled,
where the logic of the program is.
4:55
Typically you can have logic
in the front end as well, but
4:59
the back end is really where
the power of a program comes from.
5:03
You can have a static front end page, but
5:07
I like to think that
they're better together.
5:10
And it reminds me of something,
5:13
I like to make connections to things that
I already know to help things stick.
5:15
And this is a particularly sticky example,
but
5:19
this is the thing I used
to like when I was younger.
5:22
Peanut butter is great by itself,
jelly is great by itself, but
5:25
I really like the combination of the two.
5:28
And that's what I think of
full stack development.
5:30
When you have this that back end app,
maybe it's something that isn't so
5:32
visual, you'll work with
it in the command line,
5:37
the terminal this thing here,
or you can have a web page.
5:40
That's just the front end, but the data
can't change, it's static, doesn't have so
5:44
much power.
5:48
When they're together, they're a lot
better and there's more that you can do.
5:50
Just like peanut butter and jelly.
5:53
Do we have any peanut butter and
jelly lovers?
5:55
I don't see any in the chat.
5:57
Yes, that's me.
6:00
Thank you.
6:01
Okay, cool, knew it.
6:03
Anybody like that stuff?
6:06
No, don't remember it, cool.
6:07
Let's see, so libraries and
frameworks, what are those?
6:11
If you're just starting out in JavaScript,
Professor T,
6:17
I haven't had that since childhood.
6:20
So maybe my taste buds have matured,
but I liked it back then.
6:22
Okay, libraries and
frameworks, what are those?
6:27
They're tools for developers.
6:30
When you think of your code often, there's
things that you want to do that already
6:34
done that someone else
has written the code for.
6:38
And there's no need to write that code
yourself, you have features of your app
6:41
of your own passion project or
your app that your company is working on,
6:46
that you want to build out faster and
you're focused on those features.
6:50
Frameworks and libraries can help
you get up and running quickly and
6:56
build out those common tasks.
7:00
Do some of the common things that apps
all have, whether it's routing and
7:01
creating the routes that
your pages are linked to.
7:06
Or building out the actually
the styling of the components or
7:10
really building out
the layout of your page.
7:15
Libraries and frameworks can help you
get up and running with those quick.
7:18
So you worry about your requirements and
not how necessarily that code
7:20
will be written, frameworks really
handle a lot of that for you.
7:25
And libraries are things that
you'll include in your code.
7:32
Frameworks oftentimes will kind of dictate
the code that you have, it will vary.
7:35
React is a library, Django and
7:39
Tailwind which we'll use a little
bit today, are frameworks.
7:42
As another maybe unfamiliar term,
7:48
along with these you'll also maybe
hear me talk about packages.
7:50
And that's another thing
that we'll install.
7:54
Think of those as Legos.
7:56
If your project is a Lego masterpiece,
7:59
a Lego dinosaur like my son likes to
build, then a package might be just
8:01
the single Lego that you're
adding on that has a function.
8:06
It's just a smaller piece of code or
8:11
a piece of code that has a function that
you're adding to your project against
8:13
something pre-written by someone else,
out there to maybe open source.
8:18
Let's see.
8:23
I see a question.
8:26
Tailwind is CSS, the CSS framework.
8:27
So if you're familiar with Bootstrap, then
it might be something that you'll like.
8:29
Another term that might be
unfamiliar is a REST API.
8:33
So in development we use
APIs to facilitate or
8:38
to allow that communication
between our front and back end.
8:41
A great example that I like to always
come back to is this API as a waiter.
8:47
So if you think about being in
a restaurant, you're the customer,
8:52
you're the client, you have the menu,
the menu's your web interface,
8:56
it's the thing that you're
interacting with, right.
8:59
You're reading and getting all the
information from the menu, and you'll have
9:02
a request that you'll pass on to the
waiter who will relay that to the kitchen.
9:07
So from your front end or
that interaction you're having,
9:13
you're passing on a message to
the kitchen, which is the back end.
9:16
That's where all the assets are,
right, the server, the data,
9:19
which the data for our website,
food for you in this case.
9:24
And that back end is going to come with
a response that the waiter will bring back
9:29
to you, which is your food which
you're hopefully satisfied with.
9:34
Or data which you're also
hopefully satisfied with.
9:37
Sometimes with the data We have
to do a little bit of changes and
9:40
tweaking, which Python is really
great at handling on the back end.
9:45
So Django Rest framework, which is
a framework that we'll be using today,
9:51
helps us to build that back
end pretty quickly in Python.
9:57
And that's another thing about,
if I haven't said it already,
10:01
that libraries will help
you do things a lot faster.
10:05
So, we'll see that in action today.
10:09
Again, I said there's different
strokes for different folks.
10:15
So, there are different languages
depending on what you like to do.
10:18
And I've arranged these from kind of where
they lay on that full stack spectrum.
10:21
In the back end we have Python, which
is great for managing, analyzing data.
10:28
It has a lot of packages and
things that are pre-built that you can
10:33
add to your projects that are great for
handling data tons of pandas.
10:37
We have some courses on those as well,
we're working on some data analysis
10:42
content so you can learn more
about Python at Treehouse.
10:47
If you're are JavaScript, Python's
another great first or second language,
10:50
I think, if you know JavaScript already,
Python is pretty forgiving.
10:55
You don't var to declare your variables.
10:59
Best thing I'd say,
maybe just follow along with this one and
11:05
then code along after.
11:10
I'll even provide a project,
I'll provide something so
11:12
you can see all the steps later on.
11:16
You can go back and
it'll be in a GitHub repository.
11:19
So, I'll share all those things as well.
11:22
And those will be attached when it's
uploaded into Treehouse in the future.
11:23
And yeah,
I have a couple courses already in React.
11:29
I'm mostly focused on JavaScript so
far, which is the next language here.
11:32
And that is what we use for
interaction mostly.
11:37
We use it on the front end and
11:41
we can use it with React to build
out the layout of our web page.
11:42
So again, we have that back end,
the data management.
11:48
JavaScript is great at
interaction in the browser,
11:51
interacting with the user and responding
to events that happen on the page.
11:55
When you click on a page and
something happens,
12:00
that's usually JavaScript that's
handling that interaction.
12:03
And last but not least, CSS,
which we sprinkle over the top.
12:08
That is the design, the styling.
12:12
So, CSS is where you'll define the style
of your web pages or applications.
12:15
So, the specific tool that we use
today are Django REST framework.
12:22
Django is a framework that's built on
Python and helps you to get up and
12:28
running quickly and build web apps.
12:32
That was its intended purpose,
to build web apps quickly.
12:34
The same with Django REST framework.
12:39
And again, it's that back end.
12:42
So, it's processing the inputs,
those things that you're doing.
12:43
It's taking your input and providing
output and responses in the form of data.
12:47
And it also controls the logic.
12:52
So, the behavior that we're getting
is defined in those Django files,
12:54
those Python files in the Django project.
12:58
Next up, we have React, that'll be
our JavaScript framework, or sorry,
13:02
JavaScript library that we're using.
13:06
It provides the structure,
communicates messages from the brain.
13:08
Or sorry, yeah, communicates
messages to and from the brain.
13:13
So you'll click on that page, and
maybe it'll communicate with the database,
13:16
the database will send something back.
13:20
So, you can think of the JavaScript
of the front end as the face,
13:21
the Django is the brain, that back end.
13:26
And then it records incoming messages and
can kind of stores from that data.
13:31
Tailwind is a CSS framework
that uses utility classes.
13:36
So, normally in CSS you're
creating a separate CSS file.
13:40
Tailwind allows you to use these
classes in your HTML to add styles.
13:45
So, I think it's pretty intuitive,
13:52
it really depends on
the project that you're doing.
13:53
If you have a larger project, it's kind
of up to your discretion if tailwind is
13:56
something that will work for you.
14:00
I'd say to try it out though if
you've used bootstrap before.
14:01
It can be really fun and helpful.
14:05
Now, why do these things
remind me of a puppet show?
14:08
Like I mentioned before,
you have that sort of back end, or
14:11
you have the front end first in this
example, I guess, which is the puppet.
14:15
That's what the audience
is interacting with.
14:19
Is the puppet speaking?
14:23
Maybe in a puppet show there's some
interaction between the audience and
14:25
the puppet.
14:29
But that's the front end,
14:30
that's the thing that you're
maybe visually seeing or hearing.
14:31
Now, the back end, that's the brain.
14:35
There's someone behind
the puppet pulling the strings,
14:38
or if it's a sock puppet, their hands
is in the puppet, and that's the brain.
14:41
That's the logic and
that's our back end or Python code.
14:45
If this puppet has cool hair or an outfit,
14:50
then we could consider
that the CSS styling.
14:53
So, again, I like to make connections
to things that I already know.
15:00
I think it's really helpful.
15:08
I like to think of full stack
development as a car sometimes.
15:09
The interface, the steering wheel,
the dashboard, interface,
15:13
all those things you interact
with are the front end.
15:17
Under the hood,
that's where the back end lives.
15:21
You can put bumper stickers on,
and that's your CSS, I guess.
15:26
Oops, I'm gonna through this twice.
15:32
Did anybody see that last slide?
15:34
What's the most important step?
15:35
Anyone wanna answer in the chat?
15:36
Before we write any code,
what should we do?
15:38
All right, thank you,
I know I gave it away.
15:40
Thank you, people are paying attention.
15:45
Awesome.
15:48
Yeah, the most important step,
I've learned this personally,
15:50
through Treehouse, through learning,
through figuring out how I learn.
15:53
Awesome, Esteban, I see mentioning
test-driven development, and yeah, that's
15:57
another way to write your code to think of
the test that you wanna write before hand.
16:01
And that's something
that I've mentioned here.
16:06
But yeah, you want to,
before you get into the text editor,
16:08
before we get into the text editor today,
think about what code we wanna write.
16:12
Think about what we want to do.
16:17
It can be frustrating to jump in there and
not know what to do next.
16:18
Or to get started, have something break.
16:22
Or to have a mess or have 100 lines
of code as I've done before, and
16:25
not know where you went wrong.
16:29
When we have that plan beforehand, we
have sort of a North Star that guides us,
16:33
something that we can fall back on and
used to just check and
16:38
see if we're sticking to the plan.
16:42
So, we'll make sure to
plan this out before.
16:46
We know that we're building a todo app,
so we'll kind of think about that.
16:50
Anyone have any idea what things we
need to do to create a todo app?
16:53
Not too deep into it, but just what
16:59
tasks that we need to accomplish.
17:04
Yeah, pseudocode.
17:16
That's something I have a workshop on
pseudocode in the Treehouse library.
17:17
Awesome, Jamar as well.
17:22
Yeah, that's where I like to start.
17:24
I think it really helps to kind of build
that foundation and build from the top up,
17:26
I guess,
I think of the back end as the bottom.
17:30
Yeah, a form to add tasks.
17:33
Awesome, that's the front end.
17:34
Thank you,
great answers going on in the chat, and
17:36
keep them coming even if I take
my eyes off that for a second.
17:39
You'll want to represent the data, right?
17:44
We have tasks,
we have todos that wanna keep track of.
17:46
Python needs a way to
understand what a task is, or
17:51
we need a way to represent tasks so
that Python can keep track of those.
17:54
Yeah, what does the data model look like?
18:00
We do that with models.
18:01
And back in code, typically,
we use models for that.
18:04
In Python, we'll have a models.py file
in our Django project that will do that.
18:07
Exactly, we need to set
up our CRUD actions.
18:12
We need to be able to create new tasks,
list or read that list of tasks
18:15
from the database, update tasks
that we have, existing tasks, and
18:20
then delete tasks when we don't want
them anymore, we finished the task.
18:24
So, thank you, great answers there.
18:30
And those are the things that we'll do,
so it helps that we know that
18:32
before going into the text editor and
aren't just writing aimlessly
18:37
We'll also need to set up the routes and
their behaviors.
18:44
And that ties into those CRUD actions.
18:47
So, if you're already familiar with
the routes, if you think of those URLs,
18:49
the web page.
18:53
When you go to a web page, there are
different routes at the top of the page,
18:54
or different URLs, and
18:58
those will be defined in the back
end in this Django project.
18:59
And each of those routes
has different behaviors.
19:03
Some of those will render a page.
19:05
Some of those will delete a todo,
delete a task for us.
19:07
The front end, and I saw we had this
mentioned, we need a form to add tasks.
19:14
So, we need somewhere to add new todos.
19:18
We need a list of todos,
a way to delete them, and
19:20
then we wanna have more
of a mobile first layout.
19:23
So, we'll think of some things
with our CSS, our styling there.
19:27
Right, and
that really takes us into Django time, so
19:30
I hope everyone's ready to code or
watch me code and follow along.
19:34
And again, this plan is actually stored
19:39
in a document in a project management tool
19:44
that we use here at
Treehouse called Asana.
19:49
Let's see, so we have the setup.
19:54
Everything is pretty much mapped
out that we'll go over today.
19:58
The back end and
the front end all of this mapped out.
20:02
The font is a great tool.
20:05
We also use Coda.
20:06
Awesome.
I see this new use that we use Coda, and
20:07
that'll be, we have courses on that,
they're a partner of ours.
20:09
Another great tool to manage
those projects and has,
20:15
I think some more customization features
you can use as well in comparison,
20:18
you can build things out in
tables in different formats.
20:21
So this is all planned out already.
20:26
But the first thing we need
to do is to make a place for
20:29
this project to live really.
20:32
So I'll do that.
20:34
I'll go into my terminal.
20:38
We're starting with some back end code.
20:41
We're starting with our Python.
20:42
And we're really starting to build out
the project in the command line before we
20:45
write code in the text editor.
20:50
So I'm in this file.
20:53
I'm in this folder called festival now.
20:55
The first thing I'll do is
create a folder called todo.
20:57
That'll be the name of our project.
21:02
And in the back end is terminal.
21:04
We can enter commands to
communicate with the computer.
21:07
We can use Python,
we can use Node and JavaScript.
21:09
The first thing I'm gonna
do is enter a few commands.
21:14
One, when we use this ampersand,
this double ampersand,
21:16
I can enter two commands and
have them run back to back.
21:19
So I'll both create that directory or
folder for the project to live in, and
21:23
then I'll change into
it with the CD command.
21:26
So now I'm there.
21:31
I use LS and we can always use that to
list out and see what files are in there.
21:32
Right now, there's nothing there yet.
21:37
I just created it.
21:38
And that's exactly how it should be.
21:39
Next we're gonna jump into the backend.
21:42
And the very first thing
we will do with the Python
21:46
project is create a virtual environment.
21:49
I use Python 3.
21:53
And a virtual environment is the place for
your code to run for
21:54
you to install the packages that you
need for a specific project, you might
21:58
have different projects that require
different versions of a Python package.
22:04
And your virtual environment
allows you to keep those together.
22:09
Keep the packages that are needed
together for a specific project.
22:13
So again out to two commands,
the first will be DMV, and
22:20
we'll create a virtual environment
with that man named DMV.
22:25
The next will be to activate that so
the virtual environment will be up and
22:29
running and we'll be able to use it.
22:35
Now that we have our virtual
environment now, and
22:41
you can see that it's running
because DMV is up there,
22:44
I will start to install packages and
I am going to install Django.
22:49
And we use PIP to install
packages into there,
22:54
just like if you're coming from JavaScript
you use NPM to manage packages.
22:57
We will use PIP install Django,
as well as the Django rest framework.
23:02
So we'll be able to use
those in our project, and
23:09
actually installing those packages needs.
23:11
Now, we'll take a second there.
23:17
Wow, sorry.
23:22
I wasn't looking at the chat for a bit.
23:23
My terminal is tiny.
23:28
There's no need for that.
23:32
I guess I'm not sharing anything else yet.
23:34
Sorry about that.
There we go.
23:42
Cool.
23:45
So it's just a refresher.
23:46
The commands that I've used so far,
make that and CD into that directory.
23:48
Created a random virtual environment,
and then we're installing Django and
23:56
it was installed successfully.
24:01
We'll see some warnings,
you'll see that oftentimes.
24:03
They're only warnings, not errors.
24:06
That happens most of the time,
you don't have to worry about those.
24:08
The next thing we'll do now
that we have Django installed,
24:12
we're able to use the Django command.
24:18
And I'll do Django-admin.
24:22
It's as good as admin command.
24:24
Start project to create a project and
I'll name it todo.
24:26
Then I'll CD into that project,
change it to another directory as well.
24:34
So now that I'm in there,
we'll see what files we have.
24:38
We have managed that py file,
which will really hold a lot
24:41
of important commands and
do a lot for us to this project.
24:45
And then we have todo folder, which
is where the main project files live.
24:50
Some more important project
files live there as well.
24:56
Next up.
24:59
I need to just really quickly
25:04
So I can see my screen as well.
25:13
We should all be able to see it.
25:16
Here we go.
25:17
Let's see Python to create the app.
25:22
So within our projects, we can build
out individual apps within a Django or
25:27
Django rest framework project.
25:31
We can build out individual apps that have
different functionality, or our different
25:33
data representations and different
things can be handled by those apps.
25:37
So I'll do Python manage that py,
start app todo.
25:41
And for consistency,
25:47
I'll use Python 3.
25:51
Oops.
25:56
Let's name it todo app.
26:00
Lets try that Since that
app is already taken.
26:01
So now we see in that todo folder,
we have todo app and manage that py.
26:07
Another thing we wanna do is sync the
database So, just connect our project to
26:13
the database and to do that with
pythonmanage.piemigrate.commandd.
26:17
So anytime we make changes
to our data representation,
26:22
we'll need to do that again.
26:24
We'll need to make sure that
those data representation changes
26:25
are reflected there.
26:28
Now, let's see.
26:29
I want to go back.
26:39
I wanna make sure I use CD.., and
that'll just take me back into this
26:41
main folder where I want to be because
I want to start writing code now.
26:46
And I have this command code that'll open
up this folder in visual studio code.
26:52
Also have another one like Hub,
that's alias that I put in there, but
26:59
it will take me to my GitHub folder on
my computer, where many of my projects
27:03
have stored, aliases or
another cool thing that you can set up.
27:08
And are pretty much shortcuts to some of
the commands over there in the command
27:12
line, and
I'll make sure to get this to good size.
27:17
Let's see what we have, so we can see
some of the files here in that project.
27:23
And that's again,
the beauty of a framework is
27:28
that we have all this code already
that we don't need to write.
27:31
The very first place we'll go into though,
is models.py,
27:35
because we want to define a model or
a representation of our data.
27:39
And we can do that,
just like this, adding some code.
27:45
In Python if you're a JavaScriptor,
this is something to watch out for.
27:51
Indentation, it matters in Python,
just as well as these here, semi colons.
27:59
If you miss those, Python will not
forgive you, your code will not run.
28:05
And you'll wonder what's going on,
you'll run back to JavaScript.
28:10
But hopefully stick around
cuz Python is great and
28:14
can do different things to
get peanut butter and jelly.
28:16
So this model is
a representation of our data.
28:20
In Python,
we use classes to build on things,
28:23
just kinda have a base representation of,
28:27
we can structure our data
already with this class.
28:30
So we'll import that,
you often see importing.
28:35
And that's from the different
libraries that we have,
28:38
that's including these packages in our
code so that we can use them again.
28:41
So for our task model, there are a couple
of things that we wanna keep track of.
28:47
We don't necessarily need to,
but it's helpful to keep
28:51
track of these things and
just kind of see how this works.
28:56
So again, it's a real world.
29:01
It's a representation of
maybe a real world thing.
29:02
We have a task.
29:04
And if we had a car,
maybe we wanna keep track of the color,
29:06
the year making model, and
those sorts of properties.
29:09
For a task today in this app,
we're keeping it simple.
29:13
And by simple,
I don't mean that node is hard or
29:16
difficult to learn our
challenging at times.
29:19
I just mean that we're
limiting the features.
29:22
So we keep track of when this was
created and we'll store the description.
29:26
So that'll be texts, again,
don't worry about syntax.
29:31
But when we have these fields
that we can use that are again,
29:35
pre-written, pre-determine things,
and this is date time field.
29:39
So we wanna start date,
we'll use date time field.
29:44
Tomorrow's our date time field.
29:46
If we wanna store text,
we'll use our character field.
29:48
We'll set the max length to 100 so
that task can only be 100 characters long.
29:49
And it will be blank at first by default,
but
29:56
we can add a description
in When we create a task.
30:00
Next up,
we'll set some metadata about this model.
30:04
So we can use the created at or
30:10
the created property to sort
these tasks in the list.
30:13
So it'll have have an order
of creation in that list.
30:18
So that is our model.
30:22
As I mentioned before,
when there's a change in the model,
30:23
and anyone let me know if you want that
Visual Studio code a little bit larger.
30:29
I'll make it larger just in case to, So
30:35
before we hadn't made any changes,
so we didn't have to run this.
30:41
But when we do, oops, so
I need to be in todo.
30:49
I need that to be in the same
30:51
folder as manage.py to use it.
30:56
We hadn't made any changes yet.
31:02
And the command is make
migrations without the dash.
31:07
Okay, so
it's still saying no changes to type in.
31:12
We'll come back later if
there's any problems later on.
31:14
But now we have our model or
representation of the data.
31:19
And we've seen how that works.
31:21
The next thing that we want to do
is to create the serializer for
31:25
this data from the backend.
31:29
It will go to the frontend and
31:31
the format currently that
the frontend doesn't understand.
31:32
We'll need to create
a file called serializers.
31:34
And the serializer has
nothing to do with serial,
31:37
it just converts that data to a format
that the frontend can understand.
31:40
So that's serializers.py.
31:49
We'll use a serializer class again
to create that serializer for
31:51
us to base it off for us.
31:54
And we'll have these fields.
31:55
And the only fields that
we'll need are our model.
32:01
So we'll pass the model so
32:03
that serializer has access to the model
that we want it to translate.
32:04
And then we'll tell it which
fields are on that model.
32:09
I talked about the behavior before,
and that is views.
32:12
The views.py file is where the behavior is
32:17
determined in Django REST Framework.
32:22
In Django, typically, you'll write maybe a
little bit more code to set up your views
32:27
or write out some of the logic in there.
32:30
In Django REST Framework we have
a tool called ViewSets, and
32:32
that really simplifies a lot of
the creation of the ViewSets.
32:36
Or writing out that logic for those routes
that we mentioned earlier that handle
32:40
the CRUD, the reading, updating,
and deleting of tasks.
32:45
So the ViewSet will, let see, yeah.
32:51
The ViewSet will take the queryset, and
32:56
that is just the list of all
those objects, the tasks objects.
32:58
And it's relying on that
task model that we have.
33:02
Let's see.
33:07
That should fix that.
33:11
It's gonna make sure those
imports are correct, or
33:16
else those things won't be imported and
the code won't run.
33:19
Awesome, so again,
the ViewSet defines our behavior.
33:23
And with Django REST framework,
we write that code a lot faster.
33:26
We just provide that class, that ViewSet
class, our model that we've created,
33:30
and the serializer.
33:35
And it uses those together
to set the behavior
33:36
Now urls.py is where we'll
determine the routes,
33:44
the specific routes that we'll use.
33:50
We don't have admin setup just yet.
33:54
So I'll comment that out.
33:56
In JavaScript, Python,
you can add comments to your code to
33:59
explain things that you wanna back and
explain.
34:03
Or you can save things for later.
34:06
If you don't want something in your
code now you can get rid of it.
34:11
And you come back to it when you need it.
34:14
So the urls.py file determines
the routes that we'll go to.
34:19
So we'll have a home route.
34:23
And that'll just be when
we don't add anything
34:27
to the URL this will be worse defined.
34:33
ViewSets will really take care of
setting up those other routes for us.
34:37
And we don't have to write so
much of that code in this project.
34:40
So I'll add the correct imports here.
34:43
We'll use a tool called router to set
up those routes and register the task
34:44
routes and the task ViewSets and
connect those things together.
34:49
And from there, the next thing
we'll want to do is make sure
34:59
that the main project that
we have is connected to,
35:04
that the app that we have is included
in the main project that we have.
35:08
As well as a few other tools that we
wanna use like the rest framework and
35:13
one more called corsheaders.
35:18
So we'll need corsheaders to ensure that
our backend and frontend can communicate.
35:20
There's a few things
that we'll need to do.
35:24
Including setting the allowed
hosts to all for this.
35:26
We can do that with the wild card.
35:32
We'll give that a try.
35:34
So this means that any host,
any of the frontends that
35:37
are running on our computer
can access this backend data
35:41
And we did, let's see.
35:49
There we go.
35:52
We haven't installed the corsheader yet.
35:55
So we'll make sure to put that in there.
35:59
And there's another thing, middleware
that we'll want to add another tool.
36:04
This kinda come along with the corsheader,
and there's a spot for
36:10
those right here as well.
36:14
So again,
don't worry too much about the syntax.
36:15
These are all things I think Django
REST Framework documentation do a great
36:17
job about.
36:22
As you learn the language these
things will make more sense.
36:23
And the more practice that you give,
again,
36:26
with those courses that we have on Django,
React.
36:29
And the course that we have,
more of these things will become familiar.
36:33
So we have that middleware included now.
36:37
One thing we wanna be able
to do is have admin control.
36:41
One thing that's really cool
about Django REST Framework or
36:46
Django in general is that,
it has a built in sort of admin page,
36:49
where you can manage the data on your own.
36:52
Let's see.
36:58
And it looks like we're getting error,
urls.py, line 18.
36:59
And I have imported todo.
37:07
Let's see.
37:11
Views is, yeah,
37:13
and I have to do that.
37:19
So let's try that to see if it works.
37:26
And, Again,
37:28
on line 18 though, same sort of thing.
37:36
So it's this line.
37:43
Trying to keep it bug free,
37:48
but there's always something
especially with installing, I think.
37:50
And I'm trying just to do that, yeah.
38:01
There we go.
38:06
And it'll, type super password.
38:07
I can't tell you what it is or why it says
to show, it's definitely not 123 or ABC or
38:11
anything like that.
38:16
But you can set a password when
you're setting up your admin.
38:17
I've set the username in the command here.
38:20
So the command is create superuser.
38:23
You'll set the email after
this email flag here.
38:26
And I just put admin in that example,
fake email, that's obviously not mine.
38:29
And the username as admin,
and set my password.
38:33
So I can log in with that username and
38:36
the password that I have created
once my backend is up and running
38:38
Okay, and now we've allowed the host.
38:49
And now, let's see if it'll
lets us make those migrations.
38:52
Probably we made some more changes.
38:55
Oops, and again, that's my,
okay, so it is recognizing.
38:59
Since we've installed the app
into the main project,
39:05
it's recognizing that
we changed the model.
39:08
And up there it'll show even that
the change that has happened is that model
39:11
task has been created.
39:16
So after we do make migrations, we need
to make sure to run the migrate command.
39:21
Cool, and I think that should
get us up and running, really.
39:32
Let's see, yeah.
39:39
So that command Python
manage.py runserver,
39:48
that will run our project for us.
39:51
Running at local host 8000.
39:58
As you can see, everything we've done so
far and created this backend,
40:00
and that too much code had to be written,
a lot of this can be sort of boilerplate,
40:05
where you can format your own projects.
40:11
Django is really cool because you can
both connect it to a frontend that
40:14
is built in another language like
JavaScript in a framework like React,
40:18
your Angular or you can also,
sorry, let's see.
40:23
Yeah, you can also build
out your Python frontend,
40:29
you can use templates
to build out to Python.
40:32
Let's see, so this is our backend,
it's up and running.
40:38
That task route has
a list of all the tasks.
40:43
Again, that's the URL that we
defined with that backend.
40:46
And you can see there are no tasks yet,
but it gives us a place to post and
40:49
create new tasks.
40:54
So, Maybe that's learn Python and
40:57
I'll just add a description,
again, we set up that model.
41:02
And we know what it will look like, we
know the qualities that a task should have
41:05
in this app, the description,
and when it was created.
41:10
We can see the exact time and
where we format here.
41:13
We won't need to update that format
because we aren't using the app for
41:16
anything else.
41:20
We're not displaying that to a user.
41:21
But if we were, we might wanna change
that to something that's more readable.
41:23
The description is there learn Python.
41:27
So that's what we'll see and
we wanna pull up on the frontend.
41:29
The idea is, one, because it's the very
first task that has been created.
41:32
Some of you,
you might want to learn typeless
41:38
learning JavaScript And again,
41:44
we go back to that task list now, it has
both of the tasks that we've created.
41:51
If we say, task/1, it takes us to
just this one instance of a task.
41:55
And that's learn Python our first one.
42:01
If I wanted to edit that,
I could do a put request.
42:03
And that would edit the task there.
42:14
We go back to our main task route.
42:17
And we can see that it's
been updated again, and
42:22
that shows our backend is up and running.
42:25
Another cool thing that we
can do as I mentioned before
42:28
the admin,
I commented that route out, right?
42:33
So, we didn't have access to admin.
42:38
And I need to make sure,
To import the right package to use it.
42:43
Cool, so back then, let's give this a try.
43:00
There we go.
So we have our Django admin backend.
43:05
So this is something where you could
make this, you'd have your own password,
43:12
you're able to have to make some
changes or do them right now.
43:18
But, typically, you're able to kind of
update both who can use the app and
43:23
the data that's contained in the app.
43:28
I think I'm missing an import somewhere
but we'll get on to the important part.
43:32
I think we kind of skipped the break
today if anyone wants I'll take
43:38
a second to get some files completed or
get some files moved over.
43:43
Copied over to this project for
the next step, but that is our backend.
43:49
And that's we're able to do all that
with Django REST Framework in Django.
43:54
So, our to do project, And,
44:04
top secret, this folder here,
I have our React client.
44:09
So the client, again,
that's that frontend that we're using.
44:18
That's what the user will
interact with on the page,
44:24
we've created the data with
Django that will, I'm sorry,
44:27
the backend with Django that will manage
the data and see that, okay, cool.
44:31
So now that's already in PSC.
44:36
Let's take a closer look at our frontend.
44:42
And this is some pre-written code.
44:44
I've already gone into updated or
44:46
installed Tailwind is a pretty
quick install on their docks.
44:48
They have how you can install it,
whichever language you're using,
44:51
that's the CSS tool that we'll use.
44:55
So, you'll add a Tailwind config file,
craco config file and
44:58
a few more small changes to
get Tailwind up and running.
45:02
With React,
we can use usually a command like that
45:07
terminal here something
like create react app.
45:12
There are some commands to get up and
45:17
running with a project
like this pretty quickly.
45:18
But we'll see again, this is what
we get from that short command,
45:20
this react client with
all these node modules.
45:24
There's tons of code that's pre-written
to help you get up and running quickly.
45:27
In the source folder here, we have App.js.
45:31
And that will be sorta the brains or
like the main page we're work in for
45:35
this React app.
45:39
And you all mentioned some of the things
that we needed to do earlier to get this
45:41
up and running.
45:46
I added some comments in there.
45:47
So when you go back if you wanna take
a look at this after you can see those.
45:48
I'll make sure to update those and
have this uploaded to my GitHub soon and
45:52
I'll show you what my
GitHub is at the end.
45:58
But again, there were those three things
that we wanted to do in this project
46:01
with our frontend.
46:06
We needed to be able to list tasks,
we needed to be able to add a new task,
46:08
and we need to be able to delete tasks.
46:13
Reminder, back to the beginning,
syntax is not so important.
46:16
Don't worry about necessarily
how all these things look.
46:20
More so what they are and
that there are tools for
46:24
you to use to make writing code easier.
46:27
For example, this first line we're
importing are including hooks.
46:30
React is a way of building out those
web pages and it uses components.
46:34
So again, you can think of Legos and
46:39
pieces that are used to
build out a web page.
46:41
There are different types of components,
functional, and class.
46:44
Functional, maybe are more often used now,
and
46:48
they don't have some of the same
functionality as class components.
46:51
Hooks are sort of shortcuts that allow
us to do some of that functionality.
46:56
So one use effect is
a hook that I've added, so
47:02
that when things happen on the page,
I can run a function.
47:05
UState, I've added so
that I can keep track of data and
47:09
changes that are coming from
the database then from the user.
47:12
So the first, we'll really write
three functions to get this done.
47:16
The first function will get the data and
47:21
we'll use an API called fetch
that will grab that data.
47:24
This is that route,
that task route that we saw earlier.
47:28
We don't need any credentials or anything.
47:31
We'll set, oftentimes,
functions will come with maybe options,
47:32
and settings and
things that you can set when you run them.
47:37
For instance, if we needed credentials, we
could set them here with this property and
47:41
we don't for this.
47:45
Once we get that data
back from the backend,
47:46
we'll need to change it into
a format that we can use.
47:49
And that's gonna be JSON and
we'll store that data in the state.
47:52
Next up, we'll call useEffect to
run it again when it's needed.
47:57
So we have all those state,
we have all those items, those tasks, but
48:03
we need a list to store them on the
frontend to be able to use them later on.
48:07
So, we'll create an array to store those
list items and we'll have some logic here.
48:12
So, if the state or where we're
storing those list items is blank.
48:19
Sorry, if there is state, so if you see
if statements then no better than me,
48:25
that this means that if state exists,
then we do this.
48:29
Then we'll map over each
of those lists items and
48:34
create a dev or an element on the page.
48:37
And Destiny, I'd say, yep, just practice.
48:39
Thank you.
48:42
Building things out like this in the text
editor, I'd say if you're doing a smaller
48:44
project without something like React to
use code pin or workspaces on Treehouse,
48:49
but yeah, practice, practice,
practice, trying new things.
48:53
Trying projects on YouTube, Treehouse,
obviously the first choice,
48:57
but I'll come back to more of that later.
49:01
You're looping over those items,
those tasks that we have so
49:05
they're displayed on the screen.
49:08
And then there's another
function to handle the submit.
49:10
So, this is attached
to one of the buttons,
49:14
a button on the screen that adds tasks.
49:17
Obviously, so yeah,
this is the functionality to do that and
49:23
it's calling a POST request.
49:25
So we have different types of
requests that we can do to the API.
49:27
There's GET request to get data,
POST the request the post them,
49:30
to add things to the database.
49:34
So this function here will
allow us to add new tasks.
49:36
And lastly, function wise, we want to
delete the task when it's clicked on.
49:40
So we'll set this function
to change the text
49:47
color to put a line through
that completed task.
49:51
And then to call a DELETE request,
49:57
that's another type of request To
that specific instance of a task.
49:59
And React is pretty cool because we
have all this JavaScript code all
50:03
these functions and things and then we
have our HTML, our kind of template.
50:07
I've already included
the tailwind in there.
50:12
So as you can see, we'll see when
this is all running in a second here.
50:15
Let's get it running now actually.
50:22
I'll change with the client.
50:26
I use yarn start.
50:31
So if you're not familiar with
yarn it's similar to NPM,
50:32
you're able to run and install packages,
but again, we have just a title.
50:37
That's my to do list.
50:43
You see these classes in React,
50:45
those are class names, but BG green 200.
50:48
So, tailwind has these class names.
50:53
It's taking a second
here to load the page.
50:55
We'll come back to that, but
tailwind has these utility classes.
50:59
So, if I want the background to be green,
I use a class of background green,
51:02
200 is a lighter versus 700
would be a darker color.
51:07
And here we have it.
51:11
The to do app that comes from
that Django rest back in that we
51:12
created in this one page of React.
51:16
This is what our CSS looks like.
51:20
Oops, this is not what our CSS looks like
51:22
This is what our CSS should look like.
51:31
That's also not what our
CSS should look like.
51:41
It should be three lines of code,
just imports.
51:43
There shouldn't be anything on the CSS,
I think this is some other code.
51:46
Index.css, perfect, okay.
51:50
In our index.css that's all we have,
the css is being handled right now.
51:51
Are really in that app
JS in those class names.
51:57
And if you want the text to be really big,
52:03
like I wanted this to do lists to be
a little bit larger, I made it text 3XL.
52:05
If I want that to be small.
52:09
I could say text XS and
just change the class name.
52:12
Now, when I go back,
my title is tiny which makes no sense and
52:17
it's inaccessible.
52:21
So yeah, go back to three XL and
you can just change those.
52:27
So currently, the buttons background
is 300, so I change that to 500.
52:30
It gets a little bit darker there.
52:38
So again tailwind's pretty
quick to install and
52:41
then once you have it installed pretty
quick to add classes and style your page.
52:44
So here we have the result of all
that code and let's see if it works.
52:51
Well, that was unexpected.
53:10
Let's see.
53:13
There's got to be something going on.
53:16
Yep, definitely that's three.
53:25
For the sake of time,
I know just what to do.
53:34
I don't wanna diagnose too much,
53:46
we're almost out of time I wanna have
a little bit time for questions.
53:48
There we go.
54:12
So, perfect.
54:14
Yeah, I'm doing it,
just figured out what's going on.
54:17
I did kind of rush through
a little bit to make time,
54:20
but there we have a functioning app.
54:24
Our back end and front end are connected.
54:27
We're able to do that through those cores,
headers and things, but
54:29
we've made that,
defined the puppet master and
54:34
the puppet itself with quite a few
lines of code and comparison.
54:37
When you think about it, maybe you
still have quite a few lines to write.
54:44
When you use frameworks and libraries,
cuz maybe you're writing 500 lines of code
54:48
out of a million instead of just 500 and
that's the entire project.
54:53
It's really helpful to get up and
running quickly.
54:58
And again, has a lot of the built in
functionality and things we wanna do.
55:00
All this creation, deletion of
things is handled in the back end.
55:04
So again, when I refresh the page,
that task is gone, you can add more.
55:08
And this is an everyday task,
learn, learn, learn, keep learning.
55:14
And the message I wanna wrap up with is
to keep learning, be a lifelong learner.
55:20
If you're here,
this is the place to do it.
55:29
It's a great community to keep learning,
a great place to ask questions,
55:32
which we'll get into now.
55:36
I didn't mean to use a bunch of those.
55:38
And before we get into questions,
I'll just say,
55:40
Redwood JS is a great place
if you're a JavaScripter.
55:43
A framework that you can
build all these things out.
55:46
It's a full stack framework.
55:49
So maybe a great place to explore
full stack a little bit more.
55:53
Build a full stack app in
a language of your choice.
55:57
Again, check out those videos that
we have, the projects that we have.
56:00
Brad Travers on YouTube is great at
building those full stack projects.
56:02
You keep learning, learn about
deployment using tools like Netlify,
56:07
to take this a step further.
56:11
If you're not quite there yet,
take your time.
56:13
Go through the code, try to read the code
and see what things you can identify and
56:16
what you've already learned.
56:20
Reading code is a valuable skill.
56:22
You'll read and
review others' code on the job.
56:24
So make sure to get that practice and
56:26
it'll help you to, for authors,
I think it helps them to read.
56:29
More you read the better code author,
you'll become.
56:33
Keep learning, keep asking questions.
56:38
Don't think your question
isn't good enough to ask.
56:41
Again, this is a great community,
a great place to ask those questions.
56:46
And if you're a beginner, the best
place I think ,and we'll open it up for
56:48
some more questions if you all have any.
56:54
But thank you all for
sticking around so far,
56:57
How long have I coded?
57:07
Let's say, I think on and off since 2015.
57:09
I started with Treehouse, and I was
working sort of like a warehouse job.
57:14
And taking the courses on my
breaks at night or working,
57:22
that's the cool thing about Treehouse,
is it's so flexible.
57:26
And that you're able to
learn at your own pace.
57:31
So I had a few ventures, I took my
last class, sorry, my last term and
57:35
undergraduate.
57:40
That was a C++ class and
it piqued my interest in coding.
57:42
I didn't feel successful after.
57:45
I felt like still kind of lost.
57:48
And C++ might not have been my best
first language, but I was interested.
57:51
I stuck with it and
57:55
I found out about Treehouse sort
of in that same time period.
57:56
Started learning HTML and
CSS, from there JavaScript.
58:00
And those are definitely say, great
starting points, to learn HTML and CSS.
58:03
To learn, really from the front end back,
I think it's helpful.
58:06
Because I was able to understand
what's going on in the page or
58:11
what the structure of a page and
58:17
then understand how
JavaScript can manipulate and
58:19
how Python can provide or
control some of that data.
58:24
For a while.
58:28
A few times where I think I failed,
I didn't do the tech degree.
58:30
And I got stuck and it was hard.
58:34
I didn't ask questions and
58:37
I learnt that asking questions at some
point that the only way to move forward.
58:38
When you work in a team
you're collaborating.
58:43
It's helpful to ask those questions.
58:48
Others will ask questions of you.
58:49
It's part of communication and
a necessary part of the industry.
58:51
Lets see, different languages,
what do you think I should stick to?
58:58
So, I'd say it's up to you.
59:03
It really depends on what your path is,
what you're trying to accomplish.
59:07
Assign is a great tool, code is a great
tool for tracking some of those goals and
59:11
setting them and really visualizing and
breaking steps down and
59:14
keeping track of what you're learning.
59:17
But depending on what
you're comfortable with,
59:20
I think it's helpful when
learning two languages.
59:22
When there's crossover between subjects,
it's really helpful to me,
59:25
to make connections.
59:30
The frameworks in
JavaScript I learned Express,
59:32
so that translated to Flask,
the frameworks in Python.
59:35
You'll see similarities.
59:38
I think that it's helpful to get
really strong, as strong as you can,
59:40
in one language.
59:42
And then kinda make that shift over,
get a foundation,
59:45
be able to build things in a language and
then learn another.
59:48
If you have the time, interest and
kinda bandwidth to do two,
59:51
I'd say go for it, but
I'd say it helps to kinda focus in learn
59:56
Yeah, so Django rest is a framework and
is used for making that API.
1:00:19
That's how we were able to
communicate with the database.
1:00:23
It handles all that behind the scenes
with some of those commands.
1:00:26
Don't be nervous, destiny everyone.
1:00:31
I didn't know any of the stuff that I
talked about today before I learned it.
1:00:35
I think that in my personal experience
as well I've had, it's a blocker.
1:00:39
When you think about how much you
don't know or think about something as
1:00:45
intimidating or that you don't know it,
but the best thing you can do is take
1:00:49
a small step a day, read about it,
watch a short video about it.
1:00:53
Jennifer Northdale,
one of the Treehouse legends,
1:00:58
will tell you the best way to eat
an elephant as it bite at a time.
1:01:01
Sorry if I miss quoted that,
but that is 100% correct.
1:01:04
Write these things down.
1:01:10
Use Asana and Coda to map out these
tasks and things, map out your learning.
1:01:11
Yeah, at what point can you
move to a different language.
1:01:18
Sorry if I'm skipping anything.
1:01:21
Again, yeah,
if you feel strong and confident,
1:01:22
if you're building things in that one,
then kinda take it from there.
1:01:25
Yeah, really get competent in a language,
1:01:29
get some practice, get some experience.
1:01:33
Always be aware of holes in your learning
if you can kind of fill those out and
1:01:38
make sure that you're solid and
feel comfortable before proceeding.
1:01:44
Yeah, I would say if you're familiar
with the language like C-sharp,
1:01:58
then yeah, definitely Python,
1:02:01
as I mentioned before, is a lot more
forgiving than other languages.
1:02:03
Maybe, again, that using this word,
simpler syntax and
1:02:08
others, again, like there's things you
don't have to declare your variables.
1:02:11
But again, there's catches where
you need to make sure you're
1:02:16
indenting at the right times.
1:02:21
Within those functions the function
name will be at, you'll need to indent
1:02:23
the body of the function, things like
that, your semi colons to look out for.
1:02:28
And there are tools just like there are in
JavaScript linters things to check your
1:02:33
code as you're writing.
1:02:37
An awesome desk, and yeah, if you're
a designer, a great place to start again,
1:02:39
you have knowledge of the page,
you know what's going on the user side.
1:02:43
And you can work on that backend as well
or you can learn more about the backend.
1:02:48
Again, that can help you work with
developers, understand some of
1:02:54
the constraints that developers work with
if you're continuing your design work.
1:02:57
Do some of that development
work on your own.
1:03:01
I'd say it's not necessary to
learn older programming languages,
1:03:05
I'd say, again,
learning a language is important.
1:03:09
Look at the jobs that
you're interested in,
1:03:13
maybe look at things that you want to
build in the capabilities of the language.
1:03:16
But I'd say,
like languages like JavaScript, Python,
1:03:21
those that are really the bread and
1:03:25
butter of what we teach here are essential
in demand and great languages to learn.
1:03:28
Again, it's really about your individual
needs in which you want to accomplish.
1:03:34
So if there's a project
that you're working on or
1:03:40
you're going to a company
that uses a certain language,
1:03:42
you'll definitely wanna learn
that language the company uses.
1:03:45
Again, keep on learning.
1:03:52
Thanks, everyone, for having me.
1:03:53
We've had enough.
We'll be wrapping up in a second here.
1:03:55
But thank you all.
1:03:57
As I mentioned before,
I did a lot of learning here on Treehouse.
1:04:00
Gil Hernandez is my first
JavaScript teacher, and
1:04:04
it's the cool I get to actually kind of
create things alongside him these days.
1:04:08
So I know how important these things are,
learning and
1:04:14
trying to make this
jump into a new career.
1:04:19
So I'm always open to feedback and
listening.
1:04:24
My email is ready@teamtreehouse.
1:04:27
You can find me on GitHub @Ark20.
1:04:30
I'm on TikTok I suppose that way
because I'm old age I guess,
1:04:34
well, code_reg on TikTok.
1:04:39
We're trying to make educational
things and try to make those,
1:04:41
make the learning stick in another way,
in a shorter form.
1:04:44
And those videos are always open to
hearing from students reach out.
1:04:47
I'm on LinkedIn as well with my name.
1:04:52
Let's see.
1:04:56
I don't know if I'll make sure
the link is provided somewhere.
1:04:58
It'll be in like my teacher
profile on Treehouse.
1:05:01
Again, be sure to check out some of the
awesome existing courses that we have on
1:05:05
the topics that I mentioned today.
1:05:08
Django is in our library.
1:05:10
And once you have
an understanding of Django,
1:05:12
Megan's have some great courses on that.
1:05:13
But you can build, you can pick
up the Django rest framework from
1:05:15
the documentation or
coming back to this presentation even.
1:05:19
The same with react to be on
the lookout for some refreshes and
1:05:24
updates with our react content coming up.
1:05:28
And CSS,
I recently done a tailwind live stream.
1:05:31
Thanks, Chris.
1:05:35
Christopher recently done.
1:05:36
And Sandy will be up on GitHub today.
1:05:40
By the end of the day, I'll do that.
1:05:43
Yeah, any other questions?
1:05:46
Cool, thank you everyone for
sticking around and
1:05:56
not falling asleep during
an hour of coding.
1:05:59
Try not to write too much and
make you watch me write.
1:06:02
And thanks for your attention,
your questions and showing up today.
1:06:05
Yeah, and thanks Liz for the opportunity
1:06:10
You need to sign up for Treehouse in order to download course files.
Sign upYou need to sign up for Treehouse in order to set up Workspace
Sign up