So you downloaded the source files and it really
doesn't matter from which of the coding basics courses you chose.  
In any of them you'll find the project folder. Unzip it and open it up (now let me just drag this
into our view).
You'll see that there are 2 folders.  There's
your source folder and your deploy folder.
In flash, like in most other programming languages,
well in all programming languages that compile, as there are languages that don't compile, like
Javascript.
What that means is, there are languages
that, on the user system,
the computer has to read your code,
figure out what's going on, translate that
into a language that your computer could actually understand,
and then run those applications.
Flash is not one of those types of applications, it actually compiles.
Compiling basically means that it translates
that into some sort of machine language
that is much easier, and
less work for your computer to then decrypt and
understand. Thus, you have your source files, which is your
humanly readable
files and configurations. The source and
all things that you're going to work with like editors,
if it's your flash CS3 CS4 CS5
maybe even CS6 when it comes out.
As3.0 are your source files, but because
we want to compress the files, we want to make
sure that
it's as close to machine language
as we can, so it's easier on the processor
that the files are smaller.
We compile them into different formats
depending on the platform that it's supposed
to go to. If it's a desktop application,
we're going to compile it differently.
If we're going to run it on the web, we're going to compile
it differently and so on.
Different operating
systems, different platforms
demand different low-level interactions
with the machine.
In a way it's like
a translator, speaking in the most simplistic way.
Your source files are then translated
into a mediator language,
that then the end user or your computer
is capable of understanding.
I'm saying it's a mediator language because
we're not compiling it down into machine code.
We're compiling it into
an intermediary language just as java is
if you're familiar with java.
It's basically like a mini language,
and if you have
a flash plugin running on your browser,
then that flash plugin is the translator
that translates all what it needs to translate
into your applications. So in a way, there's three steps.
There's your source. You're deploy which is your intermediary files,
and then there's your flash player which actually
takes those files and decrypts them and breaks
them down even more and gives information to your computer
how to run it.
We care that we have our source
and our deploy.  Our source will never
upload and send to anyone if we don't want people
to access our work that we've worked on.
If you only want them to view it,
then we'll only show them our deploy files. We'll post to the web only
those deploy files, and only e-mail those and so on.
so what file formats flash?
Well, obviously we're not going to talk about all the 
different file formats that
Flash supports because that's not our main focus,
however let's see what the file formats that we're
going to be working with.
There are two different file types in our source files, 
our .FLA file type and our .AS file type.
Our FLA file type is still 
one of the most popular ways of working with flash, 
although there are ways to work without it today.
It's still here and it's very important.
What are the FLA files?
our FLA file is basically our heart.  It's
where we start everything up.
On the other hand, I'm going to first explain what the
.AS file is because it's going to make it a little bit easier.
Our .AS file is our script where we're going to put all our code.
It's only text.
While our FLA file is kind of like
our hub, our library where we could put assets in it and images,
even code as well if we wanted but we prefer not to. 
We're going to put all our
configurations and all the things we want
to set up for our file.
Then, we could choose to use external files
if we want or we could opt out, but we always
need to start from our root. Now,
while we're working on CS3, CS4, or CS5 
in our scenario we're going to always be working on FLA file
formats. Now there's obviously differences and different
file types. In AS 3.0, the preferred way of working
is putting classes into your AS files.
The way that we set up our file structures
is that
we have our main, and most of our videos are
going to be main.as,
and all our code is going to be sitting in
main.as, until we dig deeper into understanding
what classes are.  Now,
what are all the rest of the files from zero all the way to eleven?
these are associated with the video number
the you're watching, although in this tutorial
it's not, in every other
course, when you download the courses and you see
the different
numbers, these numbers correlate to the video
that you're watching.  So if you want to
grab the code instead of typing it on your own,
or you want to revisit the code later on,
you could always
open up the AS file and grab it.
Ok-so that's really it about our source.  We said
that our FLA is our
hub where all our assets are sitting and everything
that's related to our project is sitting for now.
In our .AS files is always going
to be a class which we don't really know
what that is yet, but basically from our perspective
right now is,
all of our code is going to sit inside of
our AS file type.
Now what's inside of our deploy? Let's look
into our deploy.
In our deploy folder we're going to,
most of the time in our scenario...
and there's a lot of different deployments, it
really depends where are we going to publish.
But for our sake of
coding basics, we're always just going to do
the basics, which is
our SWF, which is 
basically our compiled application, which,
as we said, our compiled application is basically
compressed and minimized and
translated into a closer level to machine
level programming language,
where it's easier for the processor and
for the flash player, throughout the different
operating systems and platforms that
flash player runs on these days,
making it easier for it to actually understand it
the same way
throughout, without the overhead of actually
compiling on run time.
Or, in other words, actually translating
our human readable code
into machine readable language.
Now, as we said, Javascript is a language
where it doesn't compile or it compiles
on the fly, so when you go into a browser and
it's javascript heavy,
a lot of times you're going to see that it's slower
than the Flash application.
The reason why it's slower than a flash
application is because your browser actually
has to first
understand what that copy is 
before you could actually start interacting
with it.
Now, modern browsers have a lot of different
interesting ways of dealing with that such as
compiling it on the fly, and so on,
but
the end point is,
because our applications are pre-compiled,
we have a little bit more control over
our content, because people can't
just see our code directly as easily.
Also, it cuts down the amount of time that it takes
the browser and the users computer to understand
what's going on.
As long as they have their flash player, they're
more or less ready to go!
Alright, so that was our SWF which is
a really critical file.  Now we wouldn't want
to by mistake, because I've seen that 
so many times,
you don't want to upload your FLA's or
AS files by mistake on to a web site,
especially if you're building it for a client.
It's very important to differentiate between
those two files types, and that's why i'm
deliberately, throughout all the projects, i'm
setting the source in one folder and the deploy
in another one.
It's a very good practice to always separate them.
Now, you're HTML file, we're not going to dig
too deep into what HTML is, but HTML is
our wrapper for flash which is going to be
enable us to run our application in a browser.
Although in our coding basics 
we're really not going to run it on a
browser, so we're not too concerned about the
HTML file, it's just the default file type
that's added into our project when we compile
it through Flash CS3 and up.
Well, previous versions as well but now
that we're talking about AS 3.0.
So, that's all I really have to say about our
file types for now.
All we have to know
is it's our main library where all of our
assets are sitting, where
everything starts from, all the
commands, all the initiation process
starts from here.
This is the heart of our source file, this
is what actually compiles.
Then we have our .AS files which are
external files that depend on our FLA.
so in our FLA we're actually going to link
our external class, our external file to our 
FLA.
Without it, it wouldn't know that
it's connected to our FLA.
Now in our deploy file we said...
Just to repeat it, we said our FLA
is our
main source file.  It's where we have our
assets.  It's not text.
It's usually bigger files.
It could have text in it but you can't open it 
in a text editor,
While your code in
external files are basically text.  You could 
open it up in text editors, it's small files,
and then we're talking about our deploy which we said
our deploy is basically our SWF
what is our SWF?
our SWF is basically, if I go back to
our FLA, it's our FLA plus any other
external assets that our FLA
requested for in compiling time and we're going to
see what that means.
In compiling time,
it then compiles it and compresses it and puts
it all into one bundle into on file.
Our HTML file is just our wrapper file that we can use
to run our application in an HTML page.
Ok-so those were our 4 file formats that we really
need to make sure that
we're comfortable with.