Link

For those of you who rather construct your own database class, using a Singleton pattern would of course be the way to go.  Instead of creating hundreds of instances of the same class, the Singleton pattern will verify to see if a connection has been made, and if so, return the existing connection.

Traditionally, you would start your class like so…

class database{
public function __construct() {};
}

and you would call on the class as such:

$db = new database;

When using a singleton pattern, your connection would be slightly different:

class database {
private static $instance;
private $connection;

private function __construct() {
$this->initiate_connection();
}

public static function get_instance() {
if( !self::$instance ) {
self::$instance = new __CLASS__;
}

return self::$instance;
}
}

Now to call this would be a simple:

$database = database::get_instance();

and you have your connection.  But did you see what happened in get_instance?  first it checked to see if the instance was already created, if it has been, then it returns the already created instance to whatever is calling it.  If not, then it creates the instance, and returns that instance.

Now for the fun part, using it to keep a persistant connection.  If you noticed the construct method called $this->initiate_connection().  The function initiate_connection will by your code to create the connection to the database, then store it in the global variable $connection.  Now your connection is available to all functions in your class.

you can program initiate_connection to be smart, using a simple if statement to check for new credentials, or using default credentials, you can use your class to manage and cache multiple database connections.

For instance:

private function initiate_connection()
{
// check for a special connection, if so use special connection to create the connection.  if not use default connection.

$this->connection['connection_name'] = //your new connection;
}

as you can see, $this->connection is an array of objects.  this will allow you to hold multiple db connections under one class, and allow you to access them through a special name that you give that connection.  You can define new connections by writin a function to set them:

public function database( $db, $user, $pass, $host, $name )
{
$this->connection[$name] = mysql_pconnect( $host, $user, $pass);
mysq_select_db( $db, $this->connection[$name] );
}

now you have just defined a new connection.  by setting global variables for special db, host, user, and pass, you can make use of your already created mysql connector initiate_connection.

now you can use any db connection you want by simple letting the class know which connection to use.  You can write a setter function to do so, or define it in your function to execute the query.  For simplistic reasons, we will just define it in the function that the query will be executed in.

public function query( $sql, $connection_name ) {
return mysql_query( $sql, $this->connection[$connection_name] );
}

Now you have the raw output of the mysql query for your leisure.  to make this even better by caching the results, create a global variable called $cache and run a check to see if the sql has already been executed, if not, execute and return, or return the already executed query.

public function query( $sql, $connection_name ) {

if( exists( $this->cache[$sql] ) )
{
return $this->cache[$sql];
}
else
{
$result = mysql_query( $sql, $this->connection[$connection_name] );
$this->cache[$sql] = $result;
return $result;
}
}

now you have a cached copy of the sql statement saved to be used else where on the page if you need to.  since this is sql specific, no matter which database connection you use, it will always return the appropriate cached copy.

The end result, you should have a single class that will manage multiple db connections, cache the connection as well as cache all sql statements performed per page to ensure minimal usage of the actual database.  Using the singleton pattern ensures that the class is not created multiple times, and you can actually create the method __clone() to ensure this class cannot be cloned to avoid to many unnecessary connections to your database.  Your final code should look something like this.

class database {
private static $instance;
private $connection = array();
private $cache = array();

private function __construct() {
$this->initiate_connection();
}

public static function get_instance() {
if( !self::$instance ) {
self::$instance = new __CLASS__;
}

return self::$instance;
}

private function initiate_connection()
{
$this->connection['default'] = mysql_pconnect( $host, $user, $pass);
mysq_select_db( $db, $this->connection['default'] );
}

public function database( $db, $user, $pass, $host, $name )
{
$this->connection[$name] = mysql_pconnect( $host, $user, $pass);
mysq_select_db( $db, $this->connection[$name] );
}

public function query( $sql, $connection_name ) {

if( exists( $this->cache[$sql] ) )
{
return $this->cache[$sql];
}
else
{
$result = mysql_query( $sql, $this->connection[$connection_name] );
$this->cache[$sql] = $result;
return $result;
}
}
}

How to use:

$db = databae::get_instance();
$db->database( ‘db1′, ‘user’, ‘pass’, ‘192.168.0.100′, ‘mySpecialConnection’ );
$query1 = $db->query( ’select * from table1 where firstname = “john”, ‘primary’ );
$query2 = $db->query( ’select * from table3 where pet = “cat”, ‘mySpecialConnection’ );
$query3 = $db->query( ’select * from table1 where lastname = “smith”, ‘primary’ );
$query4 = $db->query( ’select * from table4 where fish = ‘tiger oscar’, ‘mySpecialConnection’ );

now you have a bunch of queries off of multiple databases, off of one class with virtually one connection.  All results are cached until you move to the next page, so if you so need them, they are already available to you.  Makes your life easier, and your database connection more efficient.

Now days, with the recognition of the importance of search engine optimization, new ways of using JavaScript has been implemented to allow rollover links and other various effects to be readable by search engines.  Not necessarily does JavaScript produce the code on the demand, the combination of using CSS and JavaScript together allows “dynamic” content to be produced, as well as “dynamic links”.  Note that I quote them.  The content and links in fact are not dynamic and hard coded into the HTML page, however using CSS and div tags, you can hide the div until it is ready to display.  Using DOM and JavaScript, you can call on these div tags, manipulate the CSS to grab the content or links and display at your leisure.

This will allow the ability to still have the content and links visible to the search engine spiders, yet give your site more options as far as looking modern or cutting edge.  There are a lot of good open source packages out there that do this.  One of the most common is script.aculo.us. Script.aculo.us allows animated effects to your site, making it more cutting edge.

There are other ways of using JavaScript and other open source packages to achieve various effects to enhance your site.  My portofolio site zencreatives.com uses a lot of open source JavaScript packages and CSS to produce various effects, yet making the page completely readable by a search engine.

Also a thing to note, all the JavaScript is kept in a seperate JS file.  You do not want code on your page that is not necessary.  This will wieght down your page, not to mention, to much JavaScript can keep a search engine spider from wanting to crawl the rest of your site.

Some time in the near future, I will put up working code samples and using open source packages to show you how it can be done.  Not to mention I will show you how to tweak open source packages to achieve other effects that you may need.  If you have any questions as to how to do something, feel free to leave a comment, and I will compile a list to make tutorials on.  I will create them as I recieve requests or the ones that are most commonly needed.  So stay tuned.

Using Javascript can be used and yet still achieve search engine optimization, however, flash will not get ranked.  And this is important to know.  What is your goal for your site?  Knowing this will be key.  Ranking in search engines is a process that takes time to achieve.  White hat SEO does not happen over night, or even months.  Often time to get good quality rankings, you need atleast 6 months, and so much goes into what factors your score.

Time your site has been “alive” plays a key factor.  If you domain is brand new, chances are, your site will take forever and a day to get ranked.  New sites have not established any relevancy to the internet world in the search engine spider’s eyes.  However, at the same token, and brand new domain might be easier to get into the search engine.  Old domains that may been optimized using black hat techniques might have been band or label, virtually making it imposible to rankings.  A brand new domain has no history, therefore it’s history will be built.  If you do things correctly, the search engines will love you, and before you know it, natural traffic will be on your way.

When building a brand new domain, it is better to build it small, then expand.  This gives it time for the search engine spiders to see a natural growth of the site.  Constantly adding new content keeps the spider hungry for more and coming back.

Targeting each pages to specific keywords or phrases is key. No more than 3 should be used on any given page.  Content should be written specifically for it.  Use proper english, however in the case of search engines, repeating keywords and phrases will not get you slapped on the hand by your english teacher.  Repeat the keywords.  Use them as much as possible, but make sure it is still gramatically correct and understandable to a human reader.  Try and keep content to approx. 300 words or roughly 3 paragraphs.

Use meta keyword and description tags.  Do not spam the keyword.  Make each page unique.  Try not to repeat the same keyword more than 5 times.

Use the keywords in an H1 and title tag in the HTML.  Proper usage of HTML tags is very important.  The days of using the tag to best achieve the look is out.  Use CSS to redefine the look of the HTML attribute or tag.  Keep your HTML code to a minimum.  Stay away from the table development, and stick more to div tags.  Keep all styling in a seperate CSS file.  Creating a pure CSS page will make a big difference in how the search engines favor your site.  Often times the pages are lighter, and the code is easier to read.

Images, keep the design images in the CSS file, and only include necessary images named after the keyword targeted for the page.  The name of the image must make sense to the image itself.  Proper usage of “Alt” tags on the images is a good idea.  Remember, what the search engine spiders want to see, is a properly formated site, this includes the content and the code.

Make sure all links on the site are readable.  Use title attributes on “a” tags.  If any javascript is used for rollover effects, make sure the link is still readable, and keep the javascript on a js file seperate from the page.

Page naming convention and folder structure.  Make sure the name is named to the keyword or phrase, and logically stored in the appropriate folder.  You would not store a page called “widgets” in a folder named “cars”.  Chances are, you will store a page named “Ford Mustang” in a folder named “cars”.  Usage of folder structures is critical when targeting main keyphrases and the sub targeting specific key phrases and keywords.  Keep your folder structure to a minimum.  It is not advisable to go in to deep.  Try and not pass more than 2 tiers deep.  Example:  somewhere.com/cars/ford-mustang.html is idea.  This is not: somewhere.com/cars/ford/mustang.html.  This is to many folders in deep and chances are, the page mustang will not be seen and put on to the back burner for another time.

Backward links is very important.  There are 2 types of links.  One way links, and two links.  One way links rank higher than two way links.  It is known that two way links are used in link building, and that two sites agree to have each other’s link on their site for the purposes of search engine optimization.  Better links are one way links.  Usually when someone finds a good read, they will naturally link to the site.  Search engines know this.  If you have a one way link to your site, and you have a lot of them, chances are, the content is good, and relevent to what the user is searching for.

As of now, search engines rely heavily on links to your site to tell them how you should be ranked.  The more links going back to your site, the better you will position.  A linking campaign is crucial when building for search engines.

Last thing, your site’s theme.  All sites have a theme.  The theme of this blog is everything about the internet.  Not much outside of the internet will be discussed.  Your site should have a theme too.  Without a theme, search engine’s will not know how to rank you or what to rank you for.  If your theme is cars, but you write or the spider interprets your content as planes, you have a big problem.  Using tools to figure out what your site’s content gives off is important.  Use them.  They really can drastically improve the ranking of your site.

This is a more in depth approach.  Tweaking an maintaining your site are important.  Tweaking your site often will teach you what little stuff works and what doesn’t.  A great deal of time will be spent, but if you’re long term goal is to get natural traffic through your site to help cut marketing costs, you will reap the rewards if you keep at it. Read webmaster forums and search engine optimization forums as much as posssible. Post and ask questions. There is so much free information out there, you just have to go get it.

Search Engine Optimization

http://www.google.com/support/webmasters/bin/answer.py?hl=en&answer=35769 - Google Webmaster Guidelines…need I say more?

http://www.seochat.com/seo-tools/ - Has a lot of free tools to help you understand what a search engine sees and helps you optimize your site for better rank.

http://tools.seobook.com/ - Has some more great tools for running ranking reports on your site and also a very useful keyword selection tool.  Works with WordTracker, and gives you the counts of how many times it was search for the popular search engines.

http://www.wordtracker.com - Good tool to use when trying to select keywords to target and help and suggestions on other keywords that maybe used to search for your site.

Pay Per Click Advertising

Google Adwords

Yahoo! Search Marketing

Microsoft Adcenter

Affiliate Marketing Networks

Hydra Network - http://www.hydranetwork.com

Commission Junction - http://www.cj.com

CPA Empire - http://www.cpaempire.com

Link Share - http://www.linkshare.com

More to come!

The days of inter-twining PHP and HTML should be something of the past, yet I find many still do it.  Even without creating a J2EE Framework, a small psuedo framework could be something that will help you rapidly deploy the site in a matter of days to a week.  Like most mainstream software engineering is concerned, you have several layers.  You will have the view or graphical interface layer, the database abstraction layer, and the processing layer.  Properly setting up classes and objects to handle each layer can greatly improve speed, reliability, and ease of trouble shooting.

Mixing PHP and HTML makes the code hard to read, hard to understand, and sends you on a needle in a haystack hunt trying to find the break.  Creating a templating layer that will read a template and combined with the processing layer can help you easily find a break when it comes to visual.  You basically know it will be in one of those components.  If you are smart, you will incorporate a debug mode to all of your classes that you can verbose out all information that is being processed and how it is being processed.  The only layer that should ever talk to the visual layer is the constructor page and the content processing layer.  Even then they really don’t need to talk.  The visual object or layer should only have to deal with the visual aspects.  The content processing layer should only have to work with the database layer to get the content ready to be inserted into the visual layer.

This will provide a basic framework that you can use through out all sites that will make it easier to deploy and rapidly deploy sites that do not need the power of an actual framework.  The typical core objects I usually have are the template class, and the content class.  Though the content class will usually be broken up into it’s own classes and subclasses based on the function of the particular page or data being processed.  The template class is basically just that.  It will grab a template, insert the necessary data, and return.  Lately I have been using PDO as a the database layer.  If you have ready my previous post on a better way of using a database object, then you already know that I initiate the database object in an autoload page, and then make that object readily available to all classes.  It cuts database tunnels to only one, and i believe is more efficient on resources.  Not to mention it makes things a whole lot easier.

It provides flexibility in changing templates on the fly, keeps the data where it belongs, and it makes the code easier to read.

To use the Wayback Machine, go to Alexa’s website at http://www.alexa.com.  Type in the name of the domain you wish to see, in the drop down, select “Site Ranking”, and hit enter.  Once you have come to the website information page, this will give you a break down of the site, how it ranks and compares to other sites, it’s importance on the internet, and other information.  On the left hand side, you will see a header saying “More to Explore“.  Right underneath that will be a link to see how the site looked back in time.  All significant changes are denoted with an asterisks(*) next to the date.

This is an intresting way to kill some time and to take a look into the past and see the evolution of a website.

How does it work?  Basically, Google is paying you, the site owner, a small chunk of change to place the ad on your site, and each time someone clicks on the ad, you make money.  For those who are currently using it, the question comes down to, how do I make more money using Google Adsense.  One of the major factors that helps is, more traffic.  The more traffic you have, the more chances of someone clicking the ad.

Google has also introduced a couple of other ways to make money using Adsense.  First, you can incorporate a “search” feature to your site powered by Google.   Each time a user searches Google through your site, and they click on an Adwords ad, you will be paid out a portion of that income.  This makes your site more interactive with the user and allows another way of generating income besides the traditional method of getting paid per click.

Another way to make money through Adsense is to use the “Referrer” program.   This is much like affiliate marketing in the sense, each time someone clicks on your link to the product, signs up, you will get paid.  There is not much to that.

If you wish not use the other methods of Adsense, it is recommended that you place your Adsense ads in highly visible spots.  It has shown that many users ready left to right, top to bottom, just like a book.  Placing your Adsense Ads in these spots can increase visibility, and help your Adsense performance.  Also, try placing several Adsense ads through out your page.  Try changing the spots the ads are shown, and keep track on which spots are producing more clicks.

If you own more than one domain or site, also try placing the ad on multiple sites.  You can put as many as you would like through one account.  The more visitors that sees your Adsense ad, the better chances you have at making extra income though Google Adsense.

It has been said that new domains don’t get ranked, as true as that maybe, I’ve had plenty of brand new domains start return results within a matter of months.  But what are the criteria on getting your site indexed and cached by Google?  Here are some tips that will surely get you’re site noticed.

First of all, not all sites will get in.  You must understand that.  What makes a site get in?  HTML coding.  Simple as that.  The downfall to many sites seeking that organic natural rankings fail to properly set their site up with clean HTML code.  When Google and other search engines come in to evaluate your site the first time around, they will usually stick around for the first 10kb of the site.  If the first 10kb of your site is bogged down with code, guess what, the search engine will not find any content, turn around, leave, and throw your site at the end of the list to be read.  This will pretty much ensure the next time Googlebot or other search engines spiders will come around again sometime when boy bands decide to come out of the closet.  HTML coding is one of the most important aspects of Search Engine Optimization that people fail to realize.

Second, read able text links are key.  Search Engines cannot read JavaScript or follow JavaScript links.  So don’t use them.  If possible, a clean linkshould be used.  Ex.

<a href=”your_page.html” title=”Page Name”>Page Name</a>

This link is easily read by search engines.   The “title” attribute gives the spider a good idea on what it is to expect.  A good idea, stuff the keyword the end page is targeted towards in that spot.

Third, theme your site.  If your site revolves around “Widgets”, make it only about widgets.  Do not try and add other categories to your site, as this will throw off the “theme” and drop your chances of getting the main keywords or key phrases targeted.

Fourth, CONTENT!!!! Good quality content with just enough keyword repetition is in order.  Content should be betwen 200 and 300 words, and about 3 paragraphs.  Make sure the content is unique, and actually provides good information to the readers.  No one wants to read or visit a site with useless content.  Most of the stuff on this blog is useless information. But people keep reading it for some reason.  (I know it baffles me off too).  All the content on your page should have a certain amount keyword density and repetition.  You should only target no more than 3 keywords per page.  Keep in mind, you are still going for a theme on the site.   If it is widgets, then stick to widgets.  Do no have content on why the sky is blue.  It has no relevance to widgets and Google will doc you for it.

Fifth, links.  Good content will automatically have links generated back to the page.  This is what you want, and what you are aiming for.  If you don’t have time to wait around for it, surf the net and find other sites related to your site, and ask for a link exchange.  Be sure before you put their link up on your site, that they put one up for you.  Check back often to ensure they didn’t take it down.  If they did, you just gave them a one way link.  One way links weight more than 2 way links.  So the idea is to get as many one way links back to your site or landing page.  Often time posting in forums related to you site with your link in the signature works.  Posting in blogs with a link back to your site works too.  I don’t do it for my site, however, I do it a lot for sites I am promoting.  Not to mention, this drives free traffic to your site, esp if the page has a lot of traffic to it.

Sixth, change your content often.  Make weekly updates if you can. Add pages.  Constantly make changes to your site.  This will keep the spiders hungry ad coming back for more.  This blog gets on average a visit from Googlebot about every 2 days if not everyday.  I personally don’t see why considering I post to this once a decade, but they seem to like it.  If you can, make daily changes, even if they are small.
Seventh, use a site map.  Have a site map built just for the purposes of having all links in your site in one page.  If you can, use the Google SiteMaps feature to let Google know how often you make changes to your site.

Generally, getting our site into search engines is not hard.  Follow these 7 steps and you should be good.  There are of course a lot of other factors that go with really optimizing a site, however as a starter, these are good steps to follow when trying to get your site noticed by the search engines.

Starting off with a simple “autoload” file I find is helpful.

<?php
include( ‘autoload.php’ );
?>

The autoload file doesn’t have to be complicated.  It can be a basic file that creates all instances to be used through out the page, not to mention autoload classes that can be called else where throughout the script.

autoload.php

<?php
include( ‘config.php’);

// loop to auto load class files

/* Single Database initiation to be used throughout the script */

$dsn = “mysql:host=localhost;dbname=my_database”;
$dbuser = “my_database_username”;
$dbpass = “my_database_password”;

$database = new PDO( $dsn, $dbuser, $dbpass );
?>

Typically it is better to define the database info in a global configuration file that will typically not change.  It keeps all important variables that will be used multiple times in one place.  But this autoload file defines the variable $database that will be used throughout the rest of the page.  This will create on instance and most importantly, 1 connection to the database to be used.

On the file that will be needing, not mention allowing class and objects to use this instance can be accomplished this way:

File:

<?php
include( ‘autoload.php’);

$sql = “select * from my_table”;

$stmt = $database->prepare( $sql );
$stmt->execute();

while( $rows = $stmt->fetchAll() )
{
// Do Something
}
?>

Passing and allowing usage in objects:

<?php
include( ‘autoload.php’ );

$helper = new helper( $database );

echo $helper->displayView();
?>

The class file:

<?php
class helper
{
private $database;

public function __construct( $database )
{
$this->database = $database;
}

public function displayView()
{
// do something
$sql = “some sql statmet”;
$stmt = $this->database->prepare( $sql );
$stmt->execute();

while( $rows = $stmt->fetchAll() )
{
// Do something
}
}
?>

As you can see, this allows one single database thread to be used across the entire page freeing resources on the server making it more efficient.

For more information on PDO visit the manual at http://www.php.net/pdo.