It is easy to spot an organization that stores passwords either completely unencrypted or encrypted using a method that allows for decryption easily.  One method to spot this insecure behavior is the ability to “recover your password” without the need of resetting it.  If you can recover your password, then someone else can easily access it as well (with the right tools).  Another method is one to spot carefully… it’s not to fear when a company requires your password to be different from your previous X passwords, but when they also look for similarities and judge your password to be “too close”.  This may come off as being a very secure tactic, when indeed it must mean that they are storing not just one, but several old passwords in a way that would make them, once again, an easy target.

So now we know some things to spot visibly that should throw up some caution flags.  What else is there to know.  There are methods of storing passwords that are more secure.  For instance, storing a “hash” or checksum of a password using an irreversible, or one-way, algorithm is a good start.  There are several hashing methods out there, some of which are better than others, but before we continue, allow me to explain what a hash is and how it can benefit secure data storage.

Sparing you from all the techno-jargon, a “hash” or checksum is an “encrypted” form of a variable.  That’s a few quotes thrown in there, technically the term hash is misused by the Internet community as is encrypted when talking about a checksum.  Encrypted would technically make the statement that the process is reversible using some sort of key.  When in all actuality there is no key, it is a one-way cypher resulting in a fixed length string of letters and numbers that is unique to the variable data.  A common hash string (MD5) is 128-bit or 32 hexadecimal characters.  In short you have 32 characters ranging from 0-9 and A-F, 16 possible choices for each character position, giving you approximately 340,000,000,000,000,000,000,000,000,000,000,000,000 possibilities.  This doesn’t eliminate the possibility of duplicate checksums, but obviously the chances of that occurrence are highly unlikely.  The benefit of storing a data in “hash” form is that if a person gets a hold of a list of passwords, they are much easier to enter than if they get a hold of just your password hashes, but there is still a weakness.

Passwords are only as good as the people that make them.  Of course a developer can submit their users to a multitude of password rules, eliminating common passwords and other occurrences, but you’re still left with the possibility of 2 people having the same password.  If 2 people have the same password, they therefor have the same hash.  So how do we eliminate this?  Now it’s getting fun!

Eliminating possible duplicate hashes in your database is the fun part, and the part that can really help you push forward into the realm of password security.  Salting your passwords is the easiest method to eliminate this rare phenomenon. A salt is small bit of data added “somewhere” to your password string.  As I said, this is where it can be a lot of fun if you’re creative.  The salt has to be stored, and should be unique to each individual user, otherwise you still have the possibility of identical hashes with the same password.  Attaching information collected during the registration process is a good start, or even using the “id” of the user.  Or you can be creative and use multiple items or even multiple times of running it through a hashing function.  This ultimately will be up to you, but I will give you a little guidance.

For convenience we will keep this easy.  The salt variable will be left undetermined in this sample so that you can fill it in with whatever you like.  Feel free to play around with it.

<?php
$salt=X;  //undetermined, replace X with something of your choosing.
$password=$_REQUEST['password'];  //Sent from a form, or other type of post/get data set.
$seasoned_password=$salt.$password; //This will joint the 2 together;
$password_hash=md5($seasoned_password);  //This can now be stored in the database along with the salt.
?>

Storing a salted hashed password will effectively eliminate the chances for duplicate password hashes, as long as the salt is wide enough variable.  Remember never to store your salt as it’s own field, hide it as something else.

I am indeed sorry if this was a little long and drawn out.  Security is not something to be taken lightly, and I hope this helps give insight in to how you can help protect your users passwords as well as the data you wish to protect.

I posted a simple heart vector last week, which I actually had a fair amount of fun making. As I was making it, I noticed how many shortcuts and simple techniques make the process of vector illustration so much easier. I’ve learned a ton of great stuff from Vectips, Vectortuts, and Abduzeedo and wanted to pass along some workflow tips of my own. Have fun.

Oh, I should stress (as though it’s not already obvious), I’m no anatomist.

First, I always find it helpful to start with a reference sketch. So go ahead and scribble up a heart, or grab the image from above. I’m sure you noticed my ugly mug in the background. I though it added just a sinister air that complements the tutorial nicely.

We’re going to start by tracing the major central shape of the heart that we’ll build from. I always like to trace using no fill, and a really bright, contrasting color, so I don’t lose my lines.

Now we’ll trace the little veins/arteries/i don’t know, with a much thicker brush with round edges. Make sure to make the overlap the the border of your first shape.

Now we’ll go through the process of blocking out the rest of your shapes. If you like, you can make the cava’s, aorta, veins, and arteries connect and end in different ways where they won’t show up in the final piece, but for my purposes, I was only concerned with the parts that would show up at the end. This step is really just more tracing.

I will be starting off with a very basic set of security rules that you will need to keep in mind in order to maintain a secure list of users and password information. Without going in to further details, I can’t stress enough the huge mistake that many authentication systems use by limiting the size, type, and strength of a users passwords as well as the mistake of how the information is stored. I plan on analyzing a few preexisting systems and show some fundamental flaws associated with them, and provide tips to help safeguard your data from any unwanted guests.

Please be sure to check back soon, as I will be posting in the next few days.

No matter what you think of his politics, U.S. presidential cantidate Barack Obama has a pretty incredible marketing and design machine behind him. One strong example of this is his “O” logo. Simple, attractive, symbolic, it’s undeniably an effective logo.

Another aspect of the Obama campaign that is attractive to a lot of American’s is the grass-roots, everybody can be involved attitude that they’ve been trying quite successfully to convey. In honor of that attitude, and just in time for the Democratic Convention, I thought I would show some really helpful Illustrator techniques by making the Obama logo. In this tutorial, we’ll be going over the Pathfinder, Envelope Warps, Opacity Masks, and Gradient Meshes. And we’ll use a drop shadow!

What’s that? You don’t think we can do it? I have three words for you my friend.

Yes. We. Can.

Step 1. Get Yourself Ready

I’m working with a 400px by 400px artboard. I’ve set a verticle gradient from #0768A4 to #168ACB. Also, it’s important you’re working in CMYK for this tutorial. I’ll explain later when we get down to the Opacity Masks.

Step 2. Lay the Foundation

Make a 350px by 350px white circle in the middle of your artboard.

Step 3. Lay Another Foundation

Select your cirlce and copy in front (ctrl + f, mac cmd + f) to make a copy in the same position. Size it down to 320px by 320px and apply the same gradient that you have on the background. You’ll want to have the light blue on the bottom of this circle, and push it up past the middle.

Step 4. And a Third Foundation

Now copy in front (ctrl + f, mac cmd + f) again, size the circle down to 175px by 175px, and change the fill to white.

Step 5. Stripes

Now we have to make the gently sloping stripes that represent the bountiful fields of the American mid-west. We start to do this by making five rectangles, alternating red and white. You can start by making one rectangle, then hold down alt (mac option) and drag the shape to make another copy. Line them up, and repeat till you have your five stripes.

Step 6. Bendy Stripes

Now it’s time to get your warp on! Yeah! Hit ctrl + alt + shift + w (mac cmd + option + shift + w) or go to Object>Envelope Distort>Make With Warp… A dialogue box will pop up. Click the preview box, so you can see what you’re doing, and set distortion just the way you like it. I have mine set to Arc, with the bend at 25%, and the horizontal distortion at -50%.

Step 7. Bendy, Stripey Ground

Now you want to size up, rotate, and align your stripes. You want the top of your shape stopping slightly below the halfway mark of your innermost white circle, representing the sunrise of a new day or something. The bottom of the stripes need to cover the bottom of the inner blue circle.

Step 8. Pathfinding

Now we’re going to use an incredibly helpful tool that I’ve used in other tutorial’s. Say hello to the Pathfinder. Select the inner blue circle, copy it in front (ctrl + f, mac cmd + f) and move the copy to the front (ctr + shift + ], mac cmd + shift + ] ). Now select your stripes, expand (Object>Envelope>Expand) and ungroup (ctrl + shift + g, mac cmd + shift + g) them. Finally, select your stripes and the blue circle copy, and hit the crop button in the pathfinder window. You should end up with this:

Now, if you’re the boring type, you could stop right here with a perfectly functional Obama logo. If you’re the adverterous type, why don’t you continue with me?

Step 9. Depth and Shadow

Now you’re going to copy the big white circle from the back, and move it to the front (remember that one? ctrl + shift + ], mac cmd + shift + ] ). Here’s another really great illustrator thing, the gradient mesh. Object>Create Gradient Mesh, then a dialogue window will popup. I set it to 3 columns and three rows. The more detail you want on your gradient, the more rows and columns you should set. For our purposes, 3 is fine.

Now we’re going to begin adding color to individual points on our mesh. Anywhere you want to darken (in my case the bottom left side of the logo) should be assigned darker shades.

In the transparency panel, we’re going to set the blend mode to multiply, and the opacity to 80.

Step 10. The Bright Horizon

Now we have to make the bright glow coming up from beyond the horizon. Any ideas on how to do this? If you said, “Let’s just use a simple white to black gradient with the blend mode set to lighten or screen.” you’d be wrong. Dead wrong.

Because of some problem, which I won’t pretend to understand, with working with CMYK in Illustrator, sometimes you can’t do lighten or screen gradients. Why don’t we just work with RGB then? Because the gradients look cruddy, that’s why.

The solution lies in something called an Opacity Mask. First select your inner blue circle, copy it, and move it to the front. Now set the fill to white and set the blend mode to lighten. While in the transparency panel, open up the more options menu and select Make Opacity Mask. Now with your opacity mask selected, make a rectangle with a white to black gradient fill. Keep in mind, the white area displays fully what’s underneath, and as you’re getting closer to black, it masks more and more.

Step 11. More Practice Masking

Now we need to set up another opacity mask for the “shine” cast by the rising sun. Copy, paste, and move to front The blue circle. Size it down slightly, and align it with the bottom of the original blue circle. Now Copy this circle, but don’t paste it yet. Set the blend mode of the white circle to Screen.

Now create an Opacity Mask on this layer, like you did for your last layer. With the opacity layer selected, paste the circle into it from your clipboard and set the fill to a black to white gradient.  Play around with your gradient till you get the effect you want.

Step 12. The Finishing Touch

To finish things off we’re going to add a little dropshadow. Select Effect>Stylize>Drop Shadow, set your settings, and go for it. I have the mode set to Multiply, opacity at 75%, x offset -10px, y offset 10px, and blur to 15px.

I hope you enjoyed this tutorial. In the next politically minded tutorial, I’m going to show you how to make a Shepard Farey inspired John McCain poster like this one:

Download the Obama Logo Asset Files Vectors

GodBless:VQ

]]> http://www.clickpopmedia.com/2009/01/23/vector-tutorial-obama-logo/feed/ 44 http://www.clickpopmedia.com/2008/07/07/collision-detection-and-game-design/ http://www.clickpopmedia.com/2008/07/07/collision-detection-and-game-design/#comments Mon, 07 Jul 2008 23:58:21 +0000 Paul http://www.clickpopmedia.com/?p=353

This is the second step in my series of tutorial, the first being Easy Keyboard Controls and Game Design. In this tutorial I will be building on what we already have, adding asteroids and the ability to crash into them.
I’ve made a few minor changes to the original code and graphics since the last tutorial, but nothing big.

So I create a MovieClip with 3 frames and a different asteroid shape on each frame (you could have more or less if you wanted). I give the asteroids their own class since each is going to have to move independently.

What I’ve done here is give my Asteroid class X and Y speed properties that work with the Move() method for motion. I intend to call the Move() method for each asteroid in the MainLoop() function.

On creation (in the constructor) I want to know if this asteroid is actually a piece of a larger asteroid or not. If it is I’m going to be passing it the base asteroid that this one is breaking off of to use it’s X:Y coordinates and speed, plus to know what size to make the new asteroid.

Now back to the Main class (in the last tutorial I called this the Asteroids class but changed it to Main since I wanted an Asteroid class).

We need to keep track of our asteroids. To do that we will use an Array. We will add this to the Main constructor:

This is just adding 6 asteroids to the stage and giving a click event to a reset button I decided to add.
dCount stands for Death Count with an obvious purpose.

The resetGame() function is just resetting all the properties to the default. I still have to make sure to remove all the asteroids before adding all new ones, but that’s it.

I moved the contents of the MainLoop() from the previous tutorial into a function called shipControl() which is now being called from the new MainLoop();

Our revised MainLoop() method is as follows:

These nested if..else statements are here to handle death and resurrection (RIGHT ON!).

So we have our asteroids flying about the screen, but we have yet to make them destroy your ship. You should notice above the call for to a method call collisionCheck();
Here is that function now:

Each asteroid does a hitTest with each point on my ship_mc. It’s important that I’m using hitTestPoint() here because it is capable of checking based on the actual shape of the movie clip. A regular hitTest between two MovieClips will only check to see if the bounding boxes are overlapping… in our case that could still be quite 20 pixels or more away from an actual collision. This is exactly what makes realistic 2D physics so difficult in ActionScript.

Anyways, the Hit Test may be a little buggy in some cases, but hitTestPoint works pretty well for us here. After we detect a hit of course we have to destroy the ship and asteroid and set the death timer. the destroyShip() function is trivial enough, but I would like to take a quick look at a line from the remove() method:

I really just need to explain how this slightly complicated jumble works. Reading this from the inner most parenthases out;

We are creating a new Asteroid object (passing it our parent asteroid that has just been destroyed).
new Asteroid(asteroids[num])

We add that Asteroid object to the end of our asteroids Array which is returning the new length of the Array.
asteroids.push(…)

We then use that new length (minus 1) to add our newest asteroid to the stage.
stage.addChild(asteroids[...-1]);

Eh, see now? Collision detection is easy! I think my next installment might be a little more interesting when I add levels, lives, and a scoring system.

… No bullets you ask? Well that’s just an extension of what I’ve already written here right? The only extra thing you have to remember is that the bullets have a limited lifespan.

If you are still confused and can’t do it on your own (if you want to learn you really aught to at least try) then you can always check out the finished source when it’s released.

The source code for the example in this tutorial can be found here: Asteroids – V2 Source

< Lesson 1: Easy Keyboard Controls and Game Design

So far this is just a skeleton of our game. We have our KEY_DOWN and KEY_UP events which will handle all of our keyboard controls later. But, more importantly, we have our mainTimer. By setting up our game engine to run based on a timer I can later change the frame rate without changing the game dynamics (I left the frame rate at 12/sec for the example above). This is also useful if your game has too many graphical elements and the frame rate drops on some machines, this will preserve the speed of the game itself.
So, please notice that I have the Timer set to “tick” every 20 milliseconds (1000 milliseconds to 1 seconds) which is about 50 ticks per second. Because of that, we are going to have some small values to work with when playing with flight speed and rotation in our ship.
But, first let us think about keyboard controls:

rpm and thrust are going to control our ships flight in the MainLoop later. The keyCode is a number which represents the key being pressed or released on the keyboard. I prefer to set a value on down because the KEY_DOWN event will be fired off numerous times very quickly if the key is held too long. I have the controls set up to work with WASD, the arrow keys, or the num pad.
To find the key values I just traced e.keyCode in the kUp() function and tried pressing the keys in question. This got me the numbers you see in the code above. The commented out traces are there to make sure we have the correct keys, since we don’t have any other indicator yet.

The next step is a simple one (except for some of the math):

Here we have initialized some variables in the constructor first. Then we filled in our MainLoop to give our spaceship some life. I would think the rotation is self evident… it’s the first line of the method. I used some constants in my math (ACCELERATION, TOP_SPEED, and FRICTION) so that I can easily adjust the game settings all in one place, without searching for the parts of the code that I need changed.
The last group of if statements above are checking to see in our ship has flown off the screen and if it has it will be moved to the other side.

That’s all for now. Next time I will probably add some asteroids and talk a little about collision detection.

You can download the source for this example here: AsteroidsSource.rar

I have another simple but neat, little tutorial here on Flash CS3 filters. This time I’m not using Tweens at all. Our effect is going to use the MouseEvent.MOUSE_MOVE event to create the illusion of a light source coming from our cursor.

To begin with we are going to make our Shadows class. This class is going to extend MovieClip, have a DropShadowFilter pre-applied to it and a public method to change the drop shadow filters distance and angle.

I hope you can see what is going on in the code. I’m simply setting all my variables equal to 0 or 1, depending on what it’s for, and applying my filter in the constructor. Also note that I’m saving all my objects in a static array. This makes it easier to call all the lightSource() methods at once in a for loop later.

In the lightSource() method we have a little bit of math that you might be unfamiliar with.
My variables dy and dx stand for distance y or x and I’m setting them equal to the distance from the point given and the center of my ShadowObject.

angle is going to be the angle of the drop shadow and it needs to be in degrees. Math.atan() is called arc-tangent in the Trigonometry world and it gives your the value of the angle opposite the Y side of a right triangle in radians. If that doesn’t make sense, just know that it’s giving me that angle I need, but in the wrong units. I convert it by multiplying by 180 and dividing by PI. Math.atan() only returns a value between -pi/2 and pi/2 (-90 to 90 degrees) which only covers half a circle, so I have to check if we actually need the other side. And, that’s what my if() statement is for.

distance is calculated using the Pythagorean theorem C^2 = A^2 + B^2 (and then divided by 10 otherwise it’s just too much).

DropAlpha, blurX, and blurY are all set pretty clearly (blur has to be positive, thus the Math.abs() or absolute value).

Finally our function creates a new drop filter with our new values and applies it to our Shadow object.

Except for trying to remember the math involved, this one has been pretty easy so far, huh? Well then, let’s try using it in a project!

So, there it is. I’m adding each letter to a different Shadow object so that their shadows move independently. I then update all the shadow light sources to the mouse’s X and Y coordinates every time the mouse moves. SO EASY!!

I have a few more ideas for cool effects that you can make with filters and I will probably post about them soon.

Download the Source Code for the example used in this post here: ShadowsSource.zip

Above is a little example menu I made for a fake game called “Top Secret.” Don’t expect a game to start when you click on the Play button. Instead, when you click a button you will get a little menu to change the rollover effects of said button.

What I’m going to be talking about for the next… however long you read this, is how to recreate these cool effects for your own projects. Hopefully you will come up with some better ideas for using filters then just rollover effects.

Setting Up The Example:
I simply typed all the text you see using whatever font seemed nice. I then selected each TextField and broke them apart by pressing Ctrl+B twice. After making each button into a MovieClip and giving them appropriate instance names (i.e. the Play button has a name of “play_mc” and you can see this in the popup menu) I felt like it was high time to make some cool rollover effects!

Working w/ The Code:
I’m just going to talk about the one filter here, since the others are all pretty much the same.

To make a blur effect we need to create a new AS class file (one for each button). We are going to use Tweens, Filters, Events, and we are extending a MovieClip, so we need to import the apropriate library classes for those:

The star in flash.events.*; just means “all of them” and it’s a quick way of importing lots of stuff at once.

Start out with making and applying our filter to get an idea of what we want:

This is the default value/filter you see before you change any settings in my example movie above.

The filters property that I’m setting in the above code is an Array property of any DisplayObject (including Sprites, MovieClips, and any other children thereof). That is why I need the square brackets, because it’s an Array.

With the filter in place we need to check for our MOUSE_OVER and MOUSE_OUT events and tween the blur filter.

A Tween object can change any Number property of almost any object over time using easing functions. To read more on Tweens you can check out Intro to ActionScript 3.0 Tweening.

Ah! Well there we go. We now have a tween that effects our X&Y blur. Notice that we have an event listener on those two tweens for TweenEvent.MOTION_CHANGE. This is because the blur filter that we are tweening is NOT the filter that is on our MovieClip. So for every step that the tween changes the blur values, we need to reapply the filter to our Button.

I’m sure you have noticed that I am making most of my functions and variables protected. This is because protected is just like private, but private will not be inherited by child classes and protected will. I want to keep inheritance because this way I can (and have) make a base class with all my effects and just have my button classes extend that base.

If you download the source for my example movie HERE, you will notice that I have almost all my code within the Rollover class and all my button classes are extending that one.

Once again, you can download the source for this tutorial and example movie here: TopSecret Example Source Code (ZIP – 958 KB)

If you are interested in some of the components I used or want to know more about working with colors, let me know in a comment and maybe I will make a separate tutorial on them.

Images came from http://www.stockvault.net/

I will be talking about how to use Flash and XML to make a simple, yet superfly, gallery.

So, let us start off by looking at my XML file’s structure:

XML is very simple to understand if you know anything about HTML’s tag structure. The XML document has a root tag <gallery> that has an attribute dir=”//url/Photos/”. Every tag has to be closed within it’s own level of the tree. Our gallery tag is closed at the bottom of the document with </gallery>. This means that all the <img> tags are elements inside the gallery element (both open and close tags combined make up an element).

Our <img> tags have several attributes, such as the images file name and it’s pixel demensions. Inside each <img> element we have a short comment about the image that will be displayed in a TextField in our Flash movie.

One important thing to notice here is that if you want to have HTML in your TextField then you need to tell the code that something is a string containing HTML and not more elements. We do this with a special bracket <![CDATA[ HTML GOES HERE ]]> Isn’t that GREAT! That right there probably made this whole tutorial worth while (that was a problem that took me a long time to solve).

OK, now that we’ve looked at the XML we need to make it work with ActionScript 3. In Adobe Flash CS3 I created a new AS3 FLA doc and a new AS doc. In the FLA I simply created some very basic MovieClips for my left and right arrows and I placed a TextField at the bottom of my stage (which I set to 600 X 700 with a black background). After naming my instances and setting up the Document Class linkage I was done with the FLA side of thing and the rest is ActionScript.

Our Document Class has to extend MovieClip so we take our first steps thusly:

In our constructor we are initializing our Loader which will contain the loaded images and we are loading our XML document. When the XML doc is done loading, the function parseXML will handle the content.

I’ve recently gotten into the habit of using protected functions rather then private functions. There is only one difference between the two and that’s that private anything won’t be inherited by child classes.
In this function I set the MouseEvents for the arrows because if the XML failed to load, there would be no reason for the arrows to work.

Alright, so I saved my XML tree in the var xml for ease of use later. I also saved the number of images in my XML doc using the length() method. Something to know about the length method is it will only tell you how many elements there are of that tag type at that level. For example, if I were to have child elements inside my img elements that would not affect the return value of xml.img.length(); It’s only telling you how many img elements are children of gallery (gallery is accessed with the var xml directly).

In that first function I’m just going to focus on the one line with the URLRequest. In order to traverse an XML tree you need start with the base. Your XML var (in our case it’s called xml) points to that base (in this case the base is gallery). So when we want to access the attribute dir in the tag gallery, we need to type xml.@dir and this will return “//url/Photos/”. The ‘@’ symbol denotes that it’s an attribute and not an element (tag).

Getting the file name is just one step further. currentImg is a Number variable that stores which image we are on. Thinking of our XML var as something similar to a bunch of nested arrays we can see how you might access a specific file name with xml.img[currentImg].@file This says we want the file attribute in the [currentImg] (first second so forth) img element which is in our base element. There are quite a few ways of finding what you need in an XML doc and you can learn more about them here.

In the second function we are displaying the text from within our XML img element. Here we aren’t accessing any attributes or anything, this is where we get the content between the open <img> and close </img> tags.

Finally we have the arrow MouseEvent handlers:

Once again I’m using the less obvious form of the if..else statement.

Well that’s about it for this level of a gallery. You can make galleries look really nice with fade transitions between images, small loading animations for larger images, scrollable thumbnail selection menu… etc.

Here is a downloadable source of my example file (images not included… get them here): XMLGallery.zip

This is the first in a series on turning the Default WP Theme into something wonderful. Today we’re going to go over the basic structure of a Wordpress Theme. I’m not going to go over the WP installation process, so check out the Wordpress 5 Minute Install if you need some help with that (if you are having any issues with the install, feel free to ask me).

By the way, we’ll be using Wordpress 2.5.1, the shiny new version of this beautiful platform.

Wp-Theme Structure: Your Main Page

style.css:
This is your CSS stylesheet for your WP theme. If you’re not familiar, CSS (Cascading Style Sheets) is a way to define the font, layout, design of your website. CSS is great because you can use one document to set the style of your entire site. Thus, if you want to change the color of all the links on your entire site, you can just change the CSS link tag. W3schools is a great resouce. Maybe we’ll do a css tutorial some time too.

header.php:
Header.php contains your posts meta tag and title information, links to stylesheets, rss information, and links to javascript. It also contains your header image and the top of your container (Page) <div> (which sets the border around your page, as well as other things such as size, positioning, etc.).

index.php:
This is the main body of the page that someone sees when they go to www.[Your Web Page].com/[WP Folder]. It contains includes for the header, sidebar, and footer.

Index.php also contains the heart of a WP page: The Loop. The loop is what WP uses to show posts, and information associated with posts, such as the author, tags, metadata. By editing the loop you can make WP do all sorts of neat and helpful things.

sidebar.php:
The sidebar contains all of your navigation in the default theme (we’ll be changing this as we go). It includes your searchform, login and administrative links, and gives you the option to display lists of categories, authors, archives, and links. There are also areas in the sidebar that display specific information depending on the page you are on.

searchform.php:
Searchform is exactly what it says. It is the form that holds your search field and button.

footer.php:
By default this file closes your container (Page) <div>. It also includes post and comments rss a link to wordpress.org (a nice thing to keep).

Press on to the next page: Individual Posts, Archives, and Search Results