A: You're already off on the wrong foot. The reason? You're thinking you need a framework to get whatever you need done.

All too often I see posts on forums or on IRC: "What framework should I use for a large networking site, like MySpace?"

1) Comon, MySpace? Ugh.

2) If you have to ask, you're doing it wrong.

3) This question will spawn a thread of everyone promoting their own personal frameworks. E-Peen war ensues.

You're asking the wrong question. Some better questions might be:
"Is there a particular framework that out performs another?"
"How is performance gauged?"
"Does it allow Master to Slave databases?"
"Does it support Memcache?"
"What kind of templating system does it use?"
"What's the ease of development?"

As you drill further and further down into these questions, you're going to discover you will have to start making comprimises.

Some frameworks eat up less CPU, but does that mean it out performs?
For a large "networking site" you'll need hundreds of database servers, so really, does any framework handle that many "out of the box" ?
If you go, "Memcache - what's that?" - then you're already set up for fail. If you find a framework that does support clusters of MC servers, will it allow you to tailor it to your needs?
As far as templating systems go, generic Smarty won't cut it. You'll need to hack, strip and extend Smarty into all sorts of weird specific configurations for optimal performance.
Ease of development? Does it work well for you? How long will it take to hack your framework into a better performing set up? How much effort goes into training new devs on the project?

You're going to find yourself coming to a realization: You need to put in a lot of work.

Reaching out for a framework is a common misconception of Jr Developers. It's easy to grab for these frameworks beacuse you don't really understand what they do.

Don't get me wrong, some of the frameworks out there are great. And not every project requires custom built frameworks.

But there's two different leagues here. While you're playing in the minors - have fun with your frameworks, use Zend, CI, Symphony, what have you.

When it comes time to play in the big leagues, leave your AA and AAA crap at the door.

There's a difference between sites that serve 1 M Unique users a month, and those that serve over 10 M unique users a day, and that difference is not found in a box, or "off the shelve."

But that begs the question, what does making an impact mean?

Making an impact.

It's coming out the door - swinging. So much of a developers role, especially in a start up, is determined by their first 3 days. Day 1, yes, come in, settle down, welcome aboard. Day 2, start asking all of the questions you had from day 1, and for heavens sake, do something besides look busy.

Day 3, you better have your shit together, and you should be swinging for the fences.

Don't ask for something to do, demand a project. And while you're doing, don't ask questions the very second you think you don't know something.

Look for the answer first.

It's this mentality that I find so damn frustrating - all of the answers should be in the code base. Run a damn grep on your project base, and find an answer. There's no excuse for any mid, to upper mid level programmer to be asking stupid questions. By stupid question, I'm refering to in the inabilty to traverse the code base in search of functions, methods, answers.

Make an impact, 3 days.

Too often I run into reviewing or helping a "professional" developer, and I can't help but mutter "you're doing it wrong..."

I feel the most important attribute that separates one developer from another is when they write for usability and maintainability.

So let's take a look at some extremely simple steps you can take to make your project's code more flexible.

1. For the love of all that there is, seperate your header and footer files. Yes, I'm still seeing this happen, often. All content that is above your generated page needs to go into a header file, and all the content below it into a footer file. So when you need to modify one line, you do it only once.

<?php
require_once(dirname(__FILE__).'/includes/header.php');
?>
<div id='content'>
<?php
	// script runs
?>
</div>
<?php
require_once(dirname(__FILE__).'/includes/footer.php');
?>

2. Create a function to generate your navigation. And when I say generate, I mean you give it some flexibility as well. This can be done even with the smallest of sites. Example:

<?php
$site_pages = array();
$site_pages[] = array('text' => 'home', 'link' => 'home.php');
$site_pages[] = array('text' => 'about', 'link' => 'about.php');
$site_pages[] = array('text' => 'partner', 'link' => 'http://www.example.domain.com/');

function buildNav($links)
{
	$output = '';
	foreach($links as $page)
	{
		$output .= "<a href=\"{$page['link']}\" title=\"{$page['text']}\">{$page['text']}</a>\n";
	}
 	return $output;
}
?>

The example above could easily be modified to allow optional values to the array, like 'enabled' => false to turn off a link. Or you could define a link "template", and use str_replace() to substitute values.

This means if you, or the customer (with any know how) can quickly update the links at any time. For more advanced sites/projects this can obviously become more complicated, but it saves even more time.

3. If you're not going to use OOP, at least use functions. Any common task or specific sequence should be placed in it's own function. An example would be our navigation function from #2. Another example would be running a query for a specific item. If you ever need to modify your table structure you'll regret having to hunt down all of your inline queries.

4. When you create 'admin' features, take the 5 minutes to create a function that actually checks if the person accessing that "super hidden" directory filled with scripts that just accept anything.

I've seen this happen even on large global community sites.

Some developers will stuff their admin scripts in a folder such as /admin/, and just assume that if data is posted there then it's ok.

The least you should do is place a session check, and place it in a function.

<?php
function isAdmin()
{
	if(!isset($_SESSION['user_name']) || !isset($_SESSION['user_id']))
	{
		return false;
	}
	else
	{
		$sql = "SELECT COUNT(*) as cnt FROM user_table WHERE user_id = ".intval($_SESSION['user_id']);
		// do the query, check it, etc.
		return true;
	}
}
?>

Then when it comes time to run your script, simply:

<?php
if(isAdmin() === false)
{
	die('Log back in');
}
?>

5. Create a wrapper for handling escape strings. If you're not using a database class (like PDO) to handle this, you'll need to do this.

Just assume that your client could have their PHP configuration change, or they change hosts, or any possible combination of changes take place.

Create a simple wrapper that will check of magic quotes, and escape for your database insert.

<?php
function cleanString($input)
{
	if(get_magic_quotes_gpc())
	{
		$input = stripslashes($input);
	}
	$output = mysql_real_escape_string(trim($input));

	return $output;
}
?>

6. Create a configuration file so you can update common yet critical variables. An example of this would be paths. Your system quickly gains adaptability if you just create a defines.php file, and place in there your simple variables.

The overall approach you should have to any project you take is that you should use an establish tool chain you have developed. It doesn't take much time or effort to create a simple set of classes that can handle just about any thing you need to create. If you wish to use functions, you can do the same. The idea is that you write once, and write it in such a manner that you can tweak it later on.

I want to share with some of you an easy way to set up your database design in a very flexible and reliable EAV like model.

EAV stands for Entity Attribute Value, which is a common design for complex database structures that require many different Entities using many different attributes with, again, many different values. It's very common to find this set up in medical offices or records.

Let's go ahead and assume a situation, and we'll work through it.

Let's say you're accepting a feed of some sort, and you need to save the items being fed to you into a database. The problem here, is that the content length of these items, attributes, and values varies.

So let's consider the following:

Item 'Node1' ->
	Attribute 'Main' ->
		Value 1
		Value 2
		Value 3
		Value 4
Item 'Node2' ->
	Attribute 'Main' ->
		Value 1
		Value 2
		Value 3
		Value 4
	Attribute 'Other' ->
		Value 1
		Value 2

Item 'Node3' ->
	Attribute 'Main' ->
		Value 1
		Value 2
		Value 3
		Value 4
		Value 5
		Value 6
		Value 7
		Value 8

Now this is a very cheap and generic example of a data structure. But we'll work with it for now.

So let's go ahead and draw some conclusions.

The Item list will come in with a name, and have Attributes. These attributes will have values. But the number of attributes and the number of values varies.

So with that in mind, we shall come up with some SQL to create some times. For this example we're going to need three tables: items, item_attributes, and attribute_values.

So here we go:


-- first our items table:
CREATE TABLE `items` (
`id` int(11) NOT NULL auto_increment,
`item_name` varchar(50) default NULL,
PRIMARY KEY (`id`)
);
-- now our item attributes
CREATE TABLE `item_attributes` (
`id` int(11) NOT NULL auto_increment,
`item_id` int(11) NOT NULL default '0',
`attribute_name` varchar(50) default NULL,
PRIMARY KEY (`id`),
KEY `item_id_attribute_name` (`item_id`,`attribute_name`)
);
-- now finally our attribute values
CREATE TABLE `attribute_values` (
`attribute_id` int(11) NOT NULL default '0',
`attribute_value` varchar(100) default NULL,
UNIQUE KEY `attribute_id` (`attribute_id`,`attribute_value`)
);


Now that we have our layout, let's take a look at how this is going to work:

Let's assume the following PHP array is a reprentation of our data...

// start up our array
$data = array();
//
// Now, let's just load it with some test data
$data['item_1'] = array();
$data['item_1']['attribute_1'] = array();
$data['item_1']['attribute_1'][] = 'value1';
$data['item_1']['attribute_1'][] = 'value2';
$data['item_1']['attribute_1'][] = 'value3';
$data['item_1']['attribute_1'][] = 'value4';
// that's good for now.
/**
* Now let's insert this int our new schema
*
* Please note, for example sake, I will not be double checking queries
* but you SHOULD check each query for an error.
**/
foreach($data as $item_name => $attributes)
{
	$sql = "INSERT INTO items (id, item_name) VALUES (NULL, '{$item_name}');";
	mysql_query($sql);
	$item_id = mysql_insert_id();
	// now let's loop through our attributes
	foreach($attributes as $attribute => $values)
	{
		// this is now our insert into the attributes...
		$sql = "INSERT INTO item_attributes (id, item_id, attribute_name) VALUES (NULL, {$item_id}, '{$attribute}');";
		mysql_query($sql);
		$attribute_id = mysql_insert_id();
		// now let's loop through the attribute values
		foreach($values as $value)
		{
			$sql = "INSERT INTO attribute_values (attribute_id, attribute_value) VALUES ({$attribute_id}, '{$value}');";
			mysql_query($sql);
		}
	}
}
?>

And there you have it - that's now how we can get our data into our database in a flexiable manner, without having to rely
on an 'excel' like database.

To get it out, we'll simply use some joins...


$sql =
"SELECT
items.item_name,
ia.attribute_name,
av.attribute_value
FROM
attribute_values AS av
JOIN item_attributes AS ia
ON (ia.id = av.attribute_id)
JOIN items AS items
ON (items.id = ia.item_id);
";


You could also use a concat_ws to make a comma seperated list, but now that you have it in your database, you can do anything you want with it

Interesting... so, if so many web devs and IT personnel have such a problem with problem solving, perhaps they're just not thinking? Let's explore some of the problems I've seen people encounter, and how I was baffled they lacked the problem solving skills to complete their tasks.

All too often, a situation will appear in just one or two flavors. One being, "Hey, this should be working but it's not..." or, "Hey, I'm stuck." Sometimes you get the nice and juicy combo. But, that being said, let's explore how I most commonly find myself approaching these two generic scenarios.

Number one, "Hey, this should be working but it's not..."

Whenever you get to this point, that usually means a couple things:

1. I have a pretty good idea on what should be happening
2. I know how it should be done
3. I've already solved this problem before, but this time it doesn't seem to be working

Number 3 is always the worst, because as a programmer, you always think back to the last time you faced a similar problem, and basically copy the way you fixed it before. If that is the case, examine what's different this time... versions, updates, different variables, etc etc, these all have an impact.

And what it really comes down to, is back tracking all of your steps.

• Did I upload the latest version of the PHP script?
  • And if so, are the changes reflected on the server side?
• Has someone else made changes to the files in use?
• Have a double checked the process against my flow charts?
• Have I tried basic debugging?
  • This means, rather briefly:
    • Echo out the variables BEFORE they're passed or referenced
    • AND AFTER they are passed or referenced.
    • Have I done a var_dump()
    • Have I turned on error_reporting(E_ALL);
    • Have I checked my error_log
    • Have I checked my mysql_error();

If you go through a simple list like that in your mind, you can quickly determine where you're missing a step.

And please, for the love of all that is holy, please, don't be afraid to TRY something even if you're not sure it'll work. You should take the basic steps to plot out your thoughts before you begin to code. For me, that usually means getting out some paper and a pen, and sketch out my idea with some notes.

Then I begin to code.

If I ever get lost in this new idea of mine, I refer to my original plan. If I realize then that my original plan was FUBAR, I simply make the adjustments to my sketch, and keep on going.

I feel that most web developers somehow feel that they can just jump straight into a project without any planning. It simply doesn't happen. All "great" projects, they start with a little planning. Sure, maybe they didn't have a road map, version control, diagrams, database designs, ticketing systems, et cetera, but they at least had an idea. And I guarantee that idea was at least written down in pseudo code.

Again, the idea here is that you HAVE a plan, and you know how things should work, so stick to your plan. You run into the problem of "It should work but it's not" when you've altered a step somewhere. Check your debugs, check your error logs, check your plan. Rinse repeat until you go mad. And don't be afraid to ask for some fresh eyes on the problem.

Number Two, "I'm stuck."

This comes down to just general programming knowledge. Or rather, how well you understand programming logic. I will often tell people, any one can be a programmer; in fact, everyone is a programmer. Programming is just solving a problem with at last one solution. You do this by breaking it down.

Identify the problem - What do I need to accomplish?
Determine the order - What needs to happen to solve this problem?
How do I apply my solution - What's my plan of action?

Let's take for example, the problem of creating an E-Mail list manager.

Identifying the problem - I know what the solution is -- an email list manager. That's my solution, now what's the problem?  Ok, this e-mail list manager is going to have a set of emails that it sends updates to everyone month. So... the problem is I need to find out how and where the e-mail addresses are stored, and I need to create a way for them to automatically be sent.

Determine the order - Well, I kind of already figured that out. I need to:

1. Get the E-Mail Address
   1. Make sure it's valid
   2. Make sure they are opted in
2. Add that Validated E-Mail address to the 'Send To' array
3. Create the body of my E-Mail
   1. One for Plain Text
   2. One for HTML
4. Apply any templating system that may be needed
5. Do a foreach() on the 'Send To' array
   1. Then send the emails

How do I apply my solution - Well, I'm going to need a CRON script that will run once a month. I will need to create a debugging / status message system so that I can record how many e-mails got sent out, and on what date, and to whom. It's pretty straight forward from there. Create the PHP script, be sure to apply the CLI items, and boom. Start.

What I'm trying to get across here, is that you need to approach things not as strictly code, but as a single thought. This is what I want, this is how I do it.

When you're running a program, you're not just running code, you're running someone's thoughts.  That's the beauty in programming, it's not just about the code, it's about someone else getting to see into your mind.

Take a look, and be prepared to be informed.