There are many ways to look

at the model view controller, or MVC, way of building software.

To keep it extremely simple,

I offer you this basic example of a to do list application.

The user of your application or website will see your views.

Views will be the front end code,

such as HTML that the user sees when they arrive to look at the to do lists.

The views are also the form that allows them to fill in items to

add to the to do list.

When data needs to go to persistent storage, or

a database of some kind, such as storing the to-do list item that was just

entered into the form in your database, that code will reside in a model.

[SOUND] Which leaves us on how to connect the view code to our model code.

This is our missing link, controllers.

[SOUND] Controllers help us fill in the blanks to validate information that comes

from the forms to set up how we handle the logic between the view and the database

and manage any errors [SOUND] that might occur in the operation of our application.

If you like bullet points, here you go.

The model, it contains database-related code.

The view, [SOUND] it will contain our user interaction code.

The controller, it links the view code to the model code,

as well as a few other miscellaneous items.

As your experience grows, so will your understanding and

opinions of what MVC means to you.

In this course,

we'll concentrate on the part of the MVC pattern that the users of your site see.

The views, can we retired the tried and

true index.php file we've seen so often as our homepage?

No need.

Let just re-purpose it as a front controller.

As a simple definition, let us say that the front controllers

are a jumping off point for all of the traffic that comes to our site, so

that all requests and responses are directed through the index.php file.

Where they may eventually move to our controllers, serve up our view code, or

in the future, make updates to our database.

The index.php is our first step for our entire application.

To see this in action, we're going to use a micro framework as our base.

It's called slim.

You may be wondering what a framework is or do we really need one for

such a simple website.

Well, yes we do need one, but we really only need a microframework.

Speaking generally a framework is a software structure that provides

us with some generic functionality that can modify to our own needs.

Slim gives us this generic functionality we need in a website application or

API with none of the excess code.

If we need more functionality, such as templating languages or

the ability to send emails, it is extremely easy to add the code

that exists in Slim and making it custom for our needs.

Here is what Slim gives us from the start.

It gives us routing.

It gives us HTTP request and response items.

Caching, middlewares, sessions, and of course overkill Military Grade Crypto.

If you don't know what all of this is, try not to let it bother you.

I will explain it to you when we get to the implementation.

Let's get started by installing Slim.

So far, we have now installed Monologue and it been able to log to our

app.txt file all by using a package just from Composer, which is great.

We haven't had to write a logger, we have only had to use a few lines of code

to actually get some errors to log to a file for us.

Now that's great, but we need to install the core or

the base of what we're going to do for the rest of this project, and that is Slim.

Slim is a micro framework that we're gonna use for this project and for

any project going forward that needs a nice, stable base.

To do that, let's go over first and find out about Slim from their website.

So head over and open up a new tab, and I'm gonna type in slim framework.

All right, the first result for

slim framework is where we want to go, slimframework.com.

So on the explanation here, right up front, Slim is a PHP micro framework

that helps you quickly write simple, yet powerful web applications and APIs.

So it only needs a few lines to really get going.

So we'll get into this in detail as we progress through this project.

But what we're gonna start with is the user guide.

So inside of the user guide we'll see a get started and

in our get started we'll see installation.

So we're gonna install using Composer and we just simply write require Slim and

then two dot star which based off of the composer wild cards,

would allow anything that's a version two point and up.

So now let's go back over how we did it before, and

install it using interactive Composer.

So we'll go back to our console, and type in composer require.

Then when it prompts us, we type in slim.

Okay, we can't see all of it so let's make our console just a little bit bigger.

We will scroll up to the top and then type in zero for Slim.

Now we hit enter and then we can just take whatever the latest version is and

then it's going to pull it for us and get our require statements set up.

Once the require statement has been set up for 2.6, we're gonna hit Enter,

because we don't want to install anything else just yet.

So now it's going to put it in the composer json, and

then run the install for us.

So it's gonna look for any requirements from Slim, and add those as well.

Okay, so it's added everything that Slim needs.

I'm gonna clear my screen here.

It's clear, and then I'm gonna bring it back down to another manageable size.

Bring it down from here and

then take a look in our vendor folder we might need to refresh.

Here inside this folder is Slim and

all of the wonderful things that make up the slim framework.

We'll get started using it next.