The problem with the term “LED backlit LCD” is that it’s a bit too long, which does not look good in advertisements and posters. Manufacturers have conveniently eliminated LCD and simply highlight “LED”, duping customers into thinking they are LED TVs, which they clearly aren’t. Today we’ll have a look at the different types of LED LCD TVs currently available that offer improved picture quality over the other or even traditional LCD TVs.

All LED Backlit TVs are not created equal

The first thing that you should know is that not all LED LCD TVs are created equal. Just because the TV may have a sticker that says “LED” on it does not mean you’ll get the same performance as the flagship model. Stop and think for a moment, if companies used the same technologies in their high-end and low-end products, no one would look at the higher end models, right?

There are predominantly two types of LED backlighting technologies; Edge-lit LEDs and Full array LEDs. The first batch of LED TVs that came out in 2009 were based on this technology and was first showcased by Samsung. Today you’ll find everyone using this technology in their “cheaper” LED LCD TVs. Edge-lit typically means the LEDs are placed around the edge, which allow companies to make slimmer TVs. There are no major advantages in this type of LED LCD over conventional LCDs when it comes to picture quality. In fact there are many uniformity issues with edge-lit LEDs, like certain areas of the TV tend to be brighter than others, which we noticed when we reviewed the Sony ZX1. This is cheaper to produce than Full array LED LCDs, since they use a fewer number of LEDs.

The other technology that can be found on most of high-end TVs of today is Full array LEDs. As the name suggests, there is a full array of LEDs (see pic) sitting behind the LCD panel. This obviously gives you a more even backlighting with little or no uniformity issues. Mid-range to high end models typically have this sort of backlighting, like the Samsung UNC6500 series. In terms of picture quality, there is no real perceptible difference when compared to an LCD. The only advantage here is lower power consumption and again a slimmer profile. The latest crop of LED LCD TVs feature Local Dimming LED technology, which changes the game altogether.

What is Local Dimming LEDs?

LG was the first to push out this technology in India and today almost all major brands have Local Dimming (LD) in their flagship models. LD on Full array LED TVs give you the better picture quality compared to the LD on Edge-lit TVs, which was introduced this year in the Samsung UNC8000 series and LG LE5500 series. The LEDs used here are similar to the Full array models except that the array is broken into different zones and the LEDs in each zone can be dimmed or brightened depending on the scene at hand.

This gives you very good black levels that rival plasmas, since the LEDs in the dark areas can be completely turned off. There is a little catch here though. The side effect of this is a slight blooming effect noticed up close when a brighter image appears suddenly over a dark background. This happens because when displaying a dark background, the LEDs in that area are mostly off and when a bright object suddenly comes into that area, the LED’s light up to full brightness and then dim down to the current selected picture mode. This happens very quickly and isn’t very noticeable when watching a movie, but if you connect a PC to it with a static background, it’s visible.
Despite this, these TV’s are capable of delivering the best picture quality among LCD TVs.

Commercial true LED TVs don’t exist yet

How would one define a LED TV? It’s when a single LED is responsible for illuminating a single pixel on the screen, which is when you could do away with the LCD panel altogether. Today’s high-end LED LCD TVs pack in around 1500 LEDs and a typical full HD panel will have around 2 million pixels. So in order for a TV to be classified as a true LED TV, we would have to have 2 million LEDs powering individual pixels, which is simply not possible today, and probably won’t be commercially viable for some time.

So you see, no matter how companies try to spin and twist words and create fancy slogans, if a TV uses an LCD panel, it’s still an LCD TV and not a LED TV. Sony and LG clearly mention this on their site as LED LCD TV, but Samsung seem to have conveniently dropped the “LCD” from all of their LED TVs, which would easily fool the misinformed.

Aren’t LED backlit TV’s supposed to be cheap?

Technically LEDs should be cheaper to produce compared to CCFL based LCDs, but our guess is that manufacturers seem to be cashing in on the hype and buzz generated by none other than them. Everybody wants a slimmer TV for easier installation, more bragging rights, etc. and we seemed to have conditioned ourselves into thinking the extra price is justified.

Another reason for LED LCDs being expensive could very well be the manufacturing process not being that mature as yet compared to LCDs.

It’s probably cheaper to manufacture an LCD, since this technology has been around for a while now and manufacturing units are more wide spread as compared to LED LCDs, which just started hitting selves a year back.

What the Future holds

In the next three to five years we should be able to see a considerable drop in prices as we adopt newer technology for cheaper and better LED LCD TVs. QD Vision is a company that claims to have developed a breakthrough technology called Quantum dots based on nano technology that is capable of delivering up to 40% more power efficiency and a color gamut over 100% of the NTSC spectrum. This is achievable due to the use of nano sized semiconductor crystals capable of emitting pure red, green and blue light.

You should see this technology hitting LED LCD models of 2011, which isn’t far away. If you were on the fence on getting an LED LCD TV then we’d say get the one with Local Dimming LEDs if you can afford it, or else simply stick with a cheaper LCD TV, as the color reproduction will be better than the “cheaper” Edge-lit models. Better still, if you have a well functioning CRT at home, stick with that and take the plunge maybe next year when prices go down south.

SOURCE: Techtree

Follow the simple 7 steps to configure the USB EVDO modem to conneect in Ubuntu.

1. Find The Modem, Vendor and ProdID
2. Detect the modem using modprobe
3. Plug in modem and see whether it has been found by using dmesg
4. Install dialer “wvdial” if it is not already installed
5. Configure /etc/wvdial.conf to put phone number, user name and password
6. Connect to Internet

Before installing the modem login as root in Terminal (Sudo -i)

STEP I Find The Modem, Vendor and ProdID
cat /proc/bus/usb/devices
S a m p l e
cat /proc/bus/usb/devices

Bus 006 Device 002: ID 04e8:6640 Samsung Electronics Co., Ltd Usb Modem Enumerator

Note: the above command will give a list of devices connected.
Please Find your device and its Vendor and ProdID

OR directly grep it
cat /proc/bus/usb/devices | grep Vendor

will give the Lines with word “Vendor” only
These are the lines significant in my case

cat /proc/bus/usb/devices | grep Vendor



OR use command

lsusb

lsusb

Using any of the above three you can find your EVDO modem – Vendor and ProdID

The vendor should be like

vendor=04e8

product=6640

STEP II Detect the modem using modprobe

Now use modprob to detect the modem

modprobe usbserial vendor=0×04e8 product=0×6640

Note : REMEMBER to add “0X” before your Vendor/ProdID
if Vendor=04e8 on modrpobe vendor=0×04e8
if ProdID=6640 on modrpobe product=0×6640

After Command ‘modprobe’ Plug the EVDO Modem to your USB port

STEP III Plug in modem and see whether it has been found by using dmesg

check the debug message using command ‘dmesg’

dmesg | tail

from the above dmesg command, you can find the modem device attached to which port.
In my case it was ttyACM0.

STEP IV Install dialer “wvdial” if it is not already installed
use command “wvdial” for connecting to internet
if ‘wvdial’ not install, install using command

apt-get install wvdial

(You can download wvdial from http://open.nit.ca/download/wvdial-1.54.0.tar.gz

or ftp://ftp.us.debian.org/debian/pool/main/w/wvdial/wvdial_1.54.0.orig.tar.gz)(check for the latest version)
STEP V Configure /etc/wvdial.conf to put phone number, user name and passowrd
then use command ‘wvdialconf’ for configuring wvdial

edit the file /etc/wvdial.conf to add phonenumber, username and passwd using command ‘gedit /etc/wvdial.conf’

gedit /etc/wvdial.conf

eg:
[Dialer Defaults]
Stupid Mode = on
Modem = /dev/ttyACM0
Baud = 9216000
Init = ATZ

Phone = #777
Username =93xxxxxxxx
Password = 93xxxxxxxx

New PPPD = yes

STEP VI Connect to Internet
Connect to Internet

use command wvdial in the terminal

wvdial

now you are connected to internet

1. Have to use HTML Helpers Image and Link, and we shall combine this 2. The CakePHP link helper is a handy tool to create links in your application. Here is the basic syntax:

<?php echo $html->link(’help!’,’/help’); ?>

And there’s a helper for creating images, too:

<?php echo $html->image(’add.gif’); ?>

Show HTML code of the image as the link:

<?php echo $html->link($html->image(’add.gif’),’/customers/add’)?>

2. For Image,
Syntax:

$html->image(string $path, array $htmlAttributes, boolean $return = false);

Example:

$html->image(’/img/images/cancel.png’, array(’class’ => ’save_button’));
3. For Link, the Syntax:

$html->link(string $title, string $url, array $htmlAttributes, string $confirmMessage = false, boolean $escapeTitle = true, boolean $return = false);

Example:

$html->link(’SAVE’, ‘/registers’, array(), false, false, false);

4. So to make an image clickable,

<?php echo $html->link($html->image(’/img/images/cancel.png’,array(’class’ => ’save_button’)), ‘/registers’, array(), false, false, false); ?>

And the best code is:
<?php echo $html->link($html->image(’add.gif’),’/customers/add’,array(’escape’=>false))?>

Hope it will help you to save time.

• Select
• Insert
• Delete
• Update
• Connect
• Disconnect

Those seem pretty basic, but I’m sure that as we go through, we’ll notice that a lot of them utilize some similar aspects, so we may have to create more classes. Here is what your class definition should look like. Notice that I made sure that the methods were created with the public keyword.

class Database
{
	public function connect()	{	}
	public function disconnect()	{	}
	public function select()		{	}
	public function insert()		{	}
	public function delete()		{	}
	public function update()	{	}
}

function connect()

This function will be fairly basic, but creating it will require us to first create a few variables. Since we want to make sure that they can’t be accessed from outside our class, we will be setting them as private. These variables will be used to store the host, username, password and database for the connection. Since they will pretty much remain constant throughout, we don’t even need to create modifier or accessor methods for it. After that, we’d just need to create a simple mysql statement to connect to the database. Of course, since as programmers we always have to assume the user (even if it is us) will do something stupid, lets add an extra layer of precaution. We can check if the user has actually connected to the database first, and if they have, there really isn’t a need to re-connect. If they haven’t then we can use their credentials to connect.

private db_host = ‘’;
private db_user = ‘’;
private db_pass = ‘’;
private db_name = ‘’; 

public function connect()
    {
        if(!$this->con)
        {
            $myconn = @mysql_connect($this->db_host,$this->db_user,$this->db_pass);
            if($myconn)
            {
                $seldb = @mysql_select_db($this->db_name,$myconn);
                if($seldb)
                {
                    $this->con = true;
                    return true;
                } else
                {
                    return false;
                }
            } else
            {
                return false;
            }
        } else
        {
            return true;
        }
    }

As you can see, it makes use of some basic mysql functions and a bit of error checking to make sure that things are going according to plan. If it connects to the database successfully it will return true, and if not, it will return false. As an added bonus it will also set the connection variable to true if the connection was successfully complete.

public function disconnect()

This function will simply check our connection variable to see if it is set to true. If it is, that means that it is connected to the database, and our script will disconnect and return true. If not, then there really isn’t a need to do anything at all.

public function disconnect()
{
	if($this->con)
	{
		if(@mysql_close())
		{
                       $this->con = false;
			return true;
		}
		else
		{
			return false;
		}
	}
}

public function select()

This is the first function where things begin to get a little complicated. Now we will be dealing with user arguments and returning the results properly. Since we don’t necessarily want to be able to use the results right away we’re also going to introduce a new variable called result, which will store the results properly. Apart from that we’re also going to create a new function that checks to see if a particular table exists in the database. Since all of our CRUD operations will require this, it makes more sense to create it separately rather than integrating it into the function. In this way, we’ll save space in our code and as such, we’ll be able to better optimize things later on. Before we go into the actual select statement, here is the tableExists function and the private results variable.

private $result = array(); 

private function tableExists($table)
    {
        $tablesInDb = @mysql_query('SHOW TABLES FROM '.$this->db_name.' LIKE "'.$table.'"');
        if($tablesInDb)
        {
            if(mysql_num_rows($tablesInDb)==1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

This function simply checks the database to see if the required table already exists. If it does it will return true and if not, it will return false.

public function select($table, $rows = '*', $where = null, $order = null)
    {
        $q = 'SELECT '.$rows.' FROM '.$table;
        if($where != null)
            $q .= ' WHERE '.$where;
        if($order != null)
            $q .= ' ORDER BY '.$order;
        if($this->tableExists($table))
       {
        $query = @mysql_query($q);
        if($query)
        {
            $this->numResults = mysql_num_rows($query);
            for($i = 0; $i < $this->numResults; $i++)
            {
                $r = mysql_fetch_array($query);
                $key = array_keys($r);
                for($x = 0; $x < count($key); $x++)
                {
                    // Sanitizes keys so only alphavalues are allowed
                    if(!is_int($key[$x]))
                    {
                        if(mysql_num_rows($query) > 1)
                            $this->result[$i][$key[$x]] = $r[$key[$x]];
                        else if(mysql_num_rows($query) < 1)
                            $this->result = null;
                        else
                            $this->result[$key[$x]] = $r[$key[$x]];
                    }
                }
            }
            return true;
        }
        else
        {
            return false;
        }
        }
else
      return false;
    }

While it does seem a little scary at first glance, this function really does a whole bunch of things. First off it accepts 4 arguments, 1 of which is required. The table name is the only thing that you need to pass to the function in order to get results back. However, if you want to customize it a bit more, you can do so by adding which rows will be pulled from the database, and you can even add a where and order clause. Of course, as long as you pass the first value, the result will default to their preset ones, so you don’t have to worry about setting all of them. The bit of code right after the arguments just serves to compile all our arguments into a select statement. Once that is done ,a check is done to see if the table exists, using our prior tableExists function. If it exists, then the function continues onwards and the query is performed. If not, it will fail.

The next section is the real magic of the code. What it does is gather the columns and data that was requested from the database. It then assigns it to our result variable. However, to make it easier for the end user, instead of auto-incrementing numeric keys, the names of the columns are used. In case you get more than one result each row that is returned is stored with a two dimensional array, with the first key being numerical and auto-incrementing, and the second key being the name of the column. If only one result is returned, then a one dimensional array is created with the keys being the columns. If no results are turned then the result variable is set to null. As I said earlier, it seems a bit confusing, but once you break things down into their individual sections, you can see that they are fairly simple and straightforward.

public function insert()

This function is a lot simpler than our prior one. It simply allows us to insert information into the database. As such we will require an additional argument to the name of the table. We will require a variable that corresponds to the values we wish to input. We can simply separate each value with a comma. Then, all we need to do is quickly check to see if our tableExists, and then build the insert statement by manipulating our arguments to form an insert statement. Then we just run our query.

public function insert($table,$values,$rows = null)
    {
        if($this->tableExists($table))
        {
            $insert = 'INSERT INTO '.$table;
            if($rows != null)
            {
                $insert .= ' ('.$rows.')';
            }

            for($i = 0; $i < count($values); $i++)
            {
                if(is_string($values[$i]))
                    $values[$i] = '"'.$values[$i].'"';
            }
            $values = implode(',',$values);
            $insert .= ' VALUES ('.$values.')';
            $ins = @mysql_query($insert);
            if($ins)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }

As you can see, this function is a lot simpler than our rather complex select statement. Our delete function will actually be even simpler.

public function delete()

This function simply deletes either a table or a row from our database. As such we must pass the table name and an optional where clause. The where clause will let us know if we need to delete a row or the whole table. If the where clause is passed, that means that entries that match will need to be deleted. After we figure all that out, it’s just a matter of compiling our delete statement and running the query.

public function delete($table,$where = null)
    {
        if($this->tableExists($table))
        {
            if($where == null)
            {
                $delete = 'DELETE '.$table;
            }
            else
            {
                $delete = 'DELETE FROM '.$table.' WHERE '.$where;
            }
            $del = @mysql_query($delete);

            if($del)
            {
                return true;
            }
            else
            {
               return false;
            }
        }
        else
        {
            return false;
        }
    }

And finally we get to our last major function. This function simply serves to update a row in the database with some new information. However, because of the slightly more complex nature of it, it will come off as a bit larger and infinitely more confusing. Never fear, it follows much of the same pattern of our previous function. First it will use our arguments to create an update statement. It will then proceed to check the database to make sure that the tableExists. If it exists, it will simply update the appropriate row. The hard part, of course, comes when we try and create the update statement. Since the update statement has rules for multiple entry updating (IE – different columns in the same row via the cunning use of comma’s), we will need to take that into account and create a way to deal with it. I have opted to pass the where clause as a single array. The first element in the array will be the name of the column being updated, and the next will be the value of the column. In this way, every even number (including 0) will be the column name, and every odd number will be the new value. The code for performing this is very simple, and is presented below outside the function:

for($i = 0; $i < count($where); $i++)
            {
                if($i%2 != 0)
                {
                    if(is_string($where[$i]))
                    {
                        if(($i+1) != null)
                            $where[$i] = '"'.$where[$i].'" AND ';
                        else
                            $where[$i] = '"'.$where[$i].'"';
                    }
                   else
                   {
                        if(($i+1) != null)
                            $where[$i] = $where[$i]. ' AND ';
                        else
                            $where[$i] = $where[$i];
                  }
                }
            }

The next section will create the part of the update statement that deals with actually setting the variables. Since you can change any number of values, I opted to go with an array where the key is the column and the value is the new value of the column. This way we can even do a check to see how many different values were passed to be updated and can add comma’s appropriately.

$keys = array_keys($rows);
            for($i = 0; $i < count($rows); $i++)
            {
                if(is_string($rows[$keys[$i]]))
                {
                    $update .= $keys[$i].'="'.$rows[$keys[$i]].'"';
                }
                else
                {
                    $update .= $keys[$i].'='.$rows[$keys[$i]];
                }
                // Parse to add commas
                if($i != count($rows)-1)
                {
                    $update .= ',';
                }
            }

Now that we’ve got those two bits of logic out of the way, the rest of the update statement is easy. Here it is presented below:

public function update($table,$rows,$where)
    {
        if($this->tableExists($table))
        {
            // Parse the where values
            // even values (including 0) contain the where rows
            // odd values contain the clauses for the row
            for($i = 0; $i < count($where); $i++)
            {
                if($i%2 != 0)
                {
                    if(is_string($where[$i]))
                    {
                        if(($i+1) != null)
                            $where[$i] = '"'.$where[$i].'" AND ';
                        else
                            $where[$i] = '"'.$where[$i].'"';
                    }
                }
            }
            $where = implode('=',$where);

            $update = 'UPDATE '.$table.' SET ';
            $keys = array_keys($rows);
            for($i = 0; $i < count($rows); $i++)
           {
                if(is_string($rows[$keys[$i]]))
                {
                    $update .= $keys[$i].'="'.$rows[$keys[$i]].'"';
                }
                else
                {
                    $update .= $keys[$i].'='.$rows[$keys[$i]];
                }

                // Parse to add commas
                if($i != count($rows)-1)
                {
                    $update .= ',';
                }
            }
            $update .= ' WHERE '.$where;
            $query = @mysql_query($update);
            if($query)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }

Now that we have that we’ve finished our last function, our simple CRUD interface for MySQL is complete. You can now create new entries, read specific entries from the database, update entries and delete things. Also, be creating and reusing this class you’ll find that you are saving yourself a lot of time and coding. Ah, the beauty of object oriented programming.

The Use

So we’ve got our class all made, but how do we use it? This part is simple. Lets start by creating a very simple system database to use in our testing. I created a database called test, and then ran the MySQL statment. You can place it in any database that you like, just make sure that you change the connection variables at the top of the script to match:

The first line is commented out simply because not everyone will need it. If you need to run that more than once, you will need to uncomment it the second time to ensure that it creates the table.

Now that our table is created and populated, it’s time to run a few simple queries on it.

<?php;
include('crud.php');
$db = new Database();
$db->connect();
$db->select('mysqlcrud');
$res = $db->getResult();
print_r($res);
?>

If done correctly, you should see the following:

Likewise we can go a step further and run an update query, and then output the results:

<?php;
$db->update('mysqlcrud',array('name'=>'Changed!'),array('id',1));
$db->update('mysqlcrud',array('name'=>'Changed2!'),array('id',2));
$res = $db->getResult();
print_r($res);
?>

We should see this

Now for a simple insert statement:

;<?php;
$db->insert('mysqlcrud',array(3,"Name 4","this@wasinsert.ed"));
$res = $db->getResult();
print_r($res);
?>

Converting an array OR object into a string(BEST METHOD)

We are going to use the functions serialize and unserialize.

These functions are very easy to use, for example converting an array or object you would do the following:


$string = serialize($objectorarray);


Now to convert the string back into an object or array we would do:


$objectorarray = unserialize($string);


It really is as simple as that, however sometimes the serialize function doesn’t do a good job at escaping characters so to get around this we do the following:


$string =base64_encode(serialize($objectorarray)); // This converts into a string

$objectorarray = unserialize( base64_decode($string)); // This converts a string into an array or object

Converting an array into a string (OLD FASHIONED METHOD).

Implode and Explode can be used to convert an array.

Look at my example below.


$myarray[] = 'Apple';

$myarray[] = ‘Orange’;

$string = implode(‘|’,$myarray);

echo $string; // This would return Apple|Orange

Using the example above, the implode function takes two parameters.  First our separator and second our array.

To now convert the string BACK into an array we use explode. See the example below.


$string = 'Apple|Orange';

$myarray = explode(‘|’,$string);

print_r($myarray);

The explode function takes pretty much the same parameters as implode except it looks for a string rather then an array.

Why would you want to convert an array or object into a string?

When saving vast amounts of data into a mysql table or even a text file, all you would need to do using the method above is save the string into the file or into a table row.  Very useful if you have plenty of dynamic data… No need to create lots of column names when you can save the object or array into a single row!

This is what Wikipedia has to say about them:

In computing, regular expressions provide a concise and flexible means for identifying strings of text of interest, such as particular characters, words, or patterns of characters. Regular expressions (abbreviated as regex or regexp, with plural forms regexes, regexps, or regexen) are written in a formal language that can be interpreted by a regular expression processor, a program that either serves as a parser generator or examines text and identifies parts that match the provided specification.

Now, that doesn’t really tell me much about the actual patterns. The regexes I’ll be going over today contains characters such as \w, \s, \1, and many others that represent something totally different from what they look like.

If you’d like to learn a little about regular expressions before you continue reading this article, I’d suggest watching the Regular Expressions for Dummies screencast series.

The eight regular expressions we’ll be going over today will allow you to match a(n): username, password, email, hex value (like #fff or #000), slug, URL, IP address, and an HTML tag. As the list goes down, the regular expressions get more and more confusing. The pictures for each regex in the beginning are easy to follow, but the last four are more easily understood by reading the explanation.

The key thing to remember about regular expressions is that they are almost read forwards and backwards at the same time. This sentence will make more sense when we talk about matching HTML tags.

Note: The delimiters used in the regular expressions are forward slashes, “/”. Each pattern begins and ends with a delimiter. If a forward slash appears in a regex, we must escape it with a backslash: “\/”.

Matching a Username

Pattern:

/^[a-z0-9_-]{3,16}$/

Description:

We begin by telling the parser to find the beginning of the string (^), followed by any lowercase letter (a-z), number (0-9), an underscore, or a hyphen. Next, {3,16} makes sure that are at least 3 of those characters, but no more than 16. Finally, we want the end of the string ($).

String that matches:

my-us3r_n4m3

String that doesn’t match:

th1s1s-wayt00_l0ngt0beausername (too long)

Matching a Password

Pattern:

/^[a-z0-9_-]{6,18}$/

Description:

Matching a password is very similar to matching a username. The only difference is that instead of 3 to 16 letters, numbers, underscores, or hyphens, we want 6 to 18 of them ({6,18}).

String that matches:

myp4ssw0rd

String that doesn’t match:

mypa$$w0rd (contains a dollar sign)

Matching a Hex Value

Pattern:

/^#?([a-f0-9]{6}|[a-f0-9]{3})$/

Description:

We begin by telling the parser to find the beginning of the string (^). Next, a number sign is optional because it is followed a question mark. The question mark tells the parser that the preceding character — in this case a number sign — is optional, but to be “greedy” and capture it if it’s there. Next, inside the first group (first group of parentheses), we can have two different situations. The first is any lowercase letter between a and f or a number six times. The vertical bar tells us that we can also have three lowercase letters between a and f or numbers instead. Finally, we want the end of the string ($).

The reason that I put the six character before is that parser will capture a hex value like #ffffff. If I had reversed it so that the three characters came first, the parser would only pick up #fff and not the other three f’s.

String that matches:

#a3c113

String that doesn’t match:

#4d82h4 (contains the letter h)

Matching a Slug

Pattern:

/^[a-z0-9-]+$/

Description:

You will be using this regex if you ever have to work with mod_rewrite and pretty URL’s. We begin by telling the parser to find the beginning of the string (^), followed by one or more (the plus sign) letters, numbers, or hyphens. Finally, we want the end of the string ($).

String that matches:

my-title-here

String that doesn’t match:

my_title_here (contains underscores)

Matching an Email

Pattern:

/^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/

Description:

We begin by telling the parser to find the beginning of the string (^). Inside the first group, we match one or more lowercase letters, numbers, underscores, dots, or hyphens. I have escaped the dot because a non-escaped dot means any character. Directly after that, there must be an at sign. Next is the domain name which must be: one or more lowercase letters, numbers, underscores, dots, or hyphens. Then another (escaped) dot, with the extension being two to six letters or dots. I have 2 to 6 because of the country specific TLD’s (.ny.us or .co.uk). Finally, we want the end of the string ($).

String that matches:

john@doe.com

String that doesn’t match:

john@doe.something (TLD is too long)

Matching a URL

Pattern:

/^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/

Description:

This regex is almost like taking the ending part of the above regex, slapping it between “http://” and some file structure at the end. It sounds a lot simpler than it really is. To start off, we search for the beginning of the line with the caret.

The first capturing group is all option. It allows the URL to begin with “http://”, “https://”, or neither of them. I have a question mark after the s to allow URL’s that have http or https. In order to make this entire group optional, I just added a question mark to the end of it.

Next is the domain name: one or more numbers, letters, dots, or hypens followed by another dot then two to six letters or dots. The following section is the optional files and directories. Inside the group, we want to match any number of forward slashes, letters, numbers, underscores, spaces, dots, or hyphens. Then we say that this group can be matched as many times as we want. Pretty much this allows multiple directories to be matched along with a file at the end. I have used the star instead of the question mark because the star says zero or more, not zero or one. If a question mark was to be used there, only one file/directory would be able to be matched.

Then a trailing slash is matched, but it can be optional. Finally we end with the end of the line.

String that matches:

http://net.tutsplus.com/about

String that doesn’t match:

http://google.com/some/file!.html (contains an exclamation point)

Matching an IP Address

Pattern:

/^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/

Description:

Now, I’m not going to lie, I didn’t write this regex; I got it from here. Now, that doesn’t mean that I can’t rip it apart character for character.

The first capture group really isn’t a captured group because

?:

was placed inside which tells the parser to not capture this group (more on this in the last regex). We also want this non-captured group to be repeated three times — the {3} at the end of the group. This group contains another group, a subgroup, and a literal dot. The parser looks for a match in the subgroup then a dot to move on.

The subgroup is also another non-capture group. It’s just a bunch of character sets (things inside brackets): the string “25″ followed by a number between 0 and 5; or the string “2″ and a number between 0 and 4 and any number; or an optional zero or one followed by two numbers, with the second being optional.

After we match three of those, it’s onto the next non-capturing group. This one wants: the string “25″ followed by a number between 0 and 5; or the string “2″ with a number between 0 and 4 and another number at the end; or an optional zero or one followed by two numbers, with the second being optional.

We end this confusing regex with the end of the string.

String that matches:

73.60.124.136 (no, that is not my IP address )

String that doesn’t match:

256.60.124.136 (the first group must be “25″ and a number between zero and five)

Matching an HTML Tag

Pattern:

/^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/

Description:

One of the more useful regexes on the list. It matches any HTML tag with the content inside. As usually, we begin with the start of the line.

First comes the tag’s name. It must be one or more letters long. This is the first capture group, it comes in handy when we have to grab the closing tag. The next thing are the tag’s attributes. This is any character but a greater than sign (>). Since this is optional, but I want to match more than one character, the star is used. The plus sign makes up the attribute and value, and the star says as many attributes as you want.

Next comes the third non-capture group. Inside, it will contain either a greater than sign, some content, and a closing tag; or some spaces, a forward slash, and a greater than sign. The first option looks for a greater than sign followed by any number of characters, and the closing tag. \1 is used which represents the content that was captured in the first capturing group. In this case it was the tag’s name. Now, if that couldn’t be matched we want to look for a self closing tag (like an img, br, or hr tag). This needs to have one or more spaces followed by “/>”.

The regex is ended with the end of the line.

String that matches:

<a href=”http://net.tutsplus.com/”>Nettuts+</a>

String that doesn’t match:

<img src=”img.jpg” alt=”My image>” /> (attributes can’t contain greater than signs)

Conclusion

I hope that you have grasped the ideas behind regular expressions a little bit better. Hopefully you’ll be using these regexes in future projects! Many times you won’t need to decipher a regex character by character, but sometimes if you do this it helps you learn. Just remember, don’t be afraid of regular expressions, they might not seem it, but they make your life a lot easier. Just try and pull out a tag’s name from a string without regular expressions!

This article introduces Object Oriented Programming (OOP) in PHP. Luis shows you how to code less and better by using some OOP concepts and PHP tricks.Object Oriented Programming in any language is the use of objects to represent functional parts of an application and real life entities. For example you may have a Person object to hold the data related to a person and even provide some functionality that this person may be capable of.

Object Oriented Programming has long been used in games to represent the objects such as a User or an Enemy, or even a Weapon. This amazing way of programming has proven just as useful in software and web development.

In my opinion any OOP language should have:

Abstract data types and information hiding

Inheritance

Polymorphism

This can all be done using PHP classes:

<?php

class Something {

// In OOP classes are usually named starting with a cap letter.

var $x;

function setX($v) {

// Methods start in lowercase then use lowercase to separate

// words in the method name example getValueOfArea()

$this->x=$v;

}

function getX() {

return $this->x;

}

}

?>

Of course you can use your own nomenclature but having a standardized one is useful.

Object Oriented Programming in PHP – Data Members and Functions

Data members are defined in PHP using a “var” declaration inside the class and they have no type until they are assigned a value. A data member might be an integer, an array, an associative array or even an object.

Methods are defined as functions inside the class, to access data members inside the methods you have to use $this->name, otherwise the variable is local to the method.

You create an object using the new operator:

$obj=new Something;

Then you can use member functions like:

$obj->setX(5);

$see=$obj->getX();

The setX member function assigns 5 to the x data member in the object obj (not in the class), then getX returns its value; 5 in this case.

You can access the data members from the object reference using for example: $obj->x=6. However, this is not a very good OOP practice.

I encourage you to set data members by defining methods to set them and access the data members by using retrieving methods.

You’ll be a good OOP programmer if you consider data members inaccessible and only use methods from the object handler. Unfortunately PHP doesn’t have a way to declare a data member private so bad code is allowed.

Inheritance

Inheritance is easy in PHP using the extends keyword:

<?php

class Another extends Something {

var $y;

function setY($v) {

// Methods start in lowercase then use uppercase initials to

// separate words in the method name example getValueOfArea()

this->y=$v;

}

function getY() {

return $this->y;

}

}

?>

Objects of the class “Another” now have all the data members and methods of the parent class (Something) plus its own data members and methods.

You can use:

$obj2=new Something;

$obj2->setX(6);

$obj2->setY(7);

Multiple-inheritance is not supported so you can’t make a class extend two or more different classes.

You can override a method in the derived class by redefining it. If we redefine getX in “Another” we can no longer access method getX in “Something”.

If you declare a data member in a derived class with the same name as a data member in a Base class the derived data member “hides” the base class data member when you access it.

Object Oriented Programming in PHP – Constructors

You might define constructors in your classes; constructors are methods with the same name as the class and are called when you create an object of the class, for example:

<?php

class Something {

var $x;

function Something($y) {

$this->x=$y;

}

function setX($v) {

$this->x=$v;

}

function getX() {

return $this->x;

}

}

?>

So you can create an object using:

$obj=new Something(6);

…and the constructor automatically assigns 6 to the data member x.

Constructors and methods are normal PHP functions so you can use default arguments.

function Something($x=”3″,$y=”5″);

Then:

$obj=new Something(); // x=3 and y=5

$obj=new Something(8); // x=8 and y=5

$obj=new Something(8,9); // x=8 and y=9

Default arguments are used in the C++ way so you can’t pass a value to Y and let X take the default value. Arguments are assigned from left to right and when no more arguments are found if the function expected more they take the default values.

When an object of a derived class is created only its constructor is called the constructor of the Parent class is not called.

This is a gotcha of PHP because constructor chaining is a classic feature of OOP, if you want to call the base class constructor you have to do it explicitly from the derived class constructor.

It works because all methods of the parent class are available at the derived class due to inheritance.

<?php

function Another() {

$this->y=5;

$this->Something(); //explicit call to base class constructor.

}

?>

Abstract Classes

A nice mechanism in OOP is the use of Abstract Classes; abstract classes are classes that cannot be instantiated and the only purpose is to define an interface for its derived classes.

Designers often use Abstract classes to force programmers to derive classes from certain base classes, so they can be certain that the new classes have some desired functionality.

There’s no standard way to do that in PHP but, if you do need this feature, just define the base class and put a “die” call in its constructor so you can be sure that the base class is never instantiated.

Now define the methods (interface) putting “die” statements in each one so if in a derived class a programmer doesn’t override the method then an error is raised.

Furthermore you might need to be sure, since PHP has no types, that some object is from a class derived from your base class, then add a method in the base class to identify the class (return “some id”) and verify this when you receive an object as an argument.

Of course this doesn’t work if the evil programmer overrides the method in the derived class but generally the problem is dealing with lazy programmers not evil ones! Of course it’s better to keep the base class unreachable from the programmers, just print the interface and make them work!

There’re no destructors in PHP.

Object Oriented Programming in PHP – Overloading

Overloading (which is different from overriding) is not supported in PHP. In OOP you “overload” a method when you define two/more methods with the same name but different number or type of parameters (depending upon the language).

PHP is a loosely typed language so overloading by types won’t work, however overloading by number of parameters doesn’t work either.

It’s very nice sometimes in OOP to overload constructors so you can build the object in different ways (passing different number of arguments). A trick to do something like that in PHP is:

<?php

class Myclass {

function Myclass() {

$name=”Myclass”.func_num_args();

$this->$name();

//Note that $this->$name() is usually wrong but here

//$name is a string with the name of the method to call.

}

function Myclass1($x) {

code;

}

function Myclass2($x,$y) {

code;

}

}

?>

With this extra working in the class the use of the class is transparent to the user:

$obj1=new Myclass(‘1′); //Will call Myclass1

$obj2=new Myclass(‘1′,’2′); //Will call Myclass2

Sometimes this is very nice.

Polymorphism

Polymorphism is defined as the ability of an object to determine which method to invoke for an object passed as argument in runtime time. For example if you have a class figure which defines a method draw and derived classes circle and rectangle, where you override the method draw you might have a function which expects an argument x and then call $x->draw().

If you have polymorphism the method draw called depends of the type of object you pass to the function.

Polymorphism is very easy and natural in interpreted languages as PHP (try to imagine a C++ compiler generating code for this case, which method do you call? You don’t know yet which type of object you have! OK, this is not the point).

So PHP happily supports polymorphism.

<?php

function niceDrawing($x) {

//Supose this is a method of the class Board.

$x->draw();

}

$obj=new Circle(3,187);

$obj2=new Rectangle(4,5);

$board->niceDrawing($obj); //will call the draw method of Circle.

$board->niceDrawing($obj2); //will call the draw method of Rectangle.

?>

Object Oriented Programming in PHP – OOP Programming in PHP

Some “purists” will say PHP is not truly an object oriented language, which is true. PHP is a hybrid language where you can use OOP and traditional procedural programming.

For large projects, however, you might want/need to use “pure” OOP in PHP declaring classes and using only objects and classes for your project.

As larger and larger projects emerge the use of OOP may help.

OOP code is easy to maintain, easy to understand and easy to reuse. Those are the foundations of software engineering. Applying those concepts to web based projects is the key to success in future web sites.

Advanced OOP Techniques in PHP

After reviewing the basic concepts of OOP I can show you some more advanced techniques:

Serialization

PHP doesn’t support persistent objects; in OOP persistent objects are objects that keep its state and functionality across multiple invocations of the application. This means having the ability to save the object to a file or database and then load the object back. The mechanism is known as serialization.

PHP has a serialize method which can be called for objects, the serialize method returns a string representation of the object. However serialize saves the data members of the object but not the methods.

In PHP4 if you serialize the object to string $s, then destroy the object, then unserialize the object to $obj you might still access the object methods! I don’t recommend this because:

The documentation doesn’t guarantee this behaviour so in future versions it might not work.

This might lead to ‘illusions’ if you save the serialized version to disk and exit the script. In future runs of the script you can’t unserialize the string to an object and expect the methods to be there because the string representation doesn’t have the methods.

You can serialize associative arrays and arrays to save them to disk too.

Example:

<?php

$obj=new Classfoo();

$str=serialize($obj);

// Save $str to disk

//…some months later

//Load str from disk

$obj2=unserialize($str)

?>

You have the data members recovered but not the methods (according to the documentation). This leads to $obj2->x as the only way to access the data members (you have no methods) so don’t try this at home.

There’re some ways to fix the problem but I leave it up to you because they are too dirty for this neat article. Full serialization is a feature I’d gladly welcome in PHP.

Using Classes to Manipulate Stored Data

One very nice thing about PHP and OOP is that you can easily define classes to manipulate certain things and the call the appropriate classes whenever you want.

Suppose you have a HTML form where the user selects a product by selecting its product ID, you have the data of the products in a database and you want to display the product, show its price, etc. You have products of different types and the same action might have different meanings for different kind of products.

For example showing a sound might mean playing it while for some other kind of products might mean to display a picture stored in the database. You might use OOP and PHP to code less and code better:

Define a class product, define which methods the class should have (example display), then define classes for each type of product which extends the product class (class SoundItem, class ViewableItem, etc.), override the methods you define in product in each of this classes make them do what you want. Name the classes according to the “type” column you store in the database for each product a typical product table might have (id, type, price, description, etc.).

Then in the processing script you can retrieve the type from the database and instantiate an object of the class named type using:

<?php

$obj=new $type();

$obj->action();

?>

This is a very nice feature of PHP, you might then call the display method of $obj or any other method regardless the type of object you have.

With this technique you don’t have to touch the processing script when you add a new type of object, just add a class to handle it. This is quite powerful, just define the methods all objects regardless of its type should have, implement them in different ways in different classes and use them for any type of object in the main script, no ifs, no 2 programmers in the same file, eternal happiness.

Do you agree programming is easy, maintenance is cheaper and reusability is real now?

If you command a group of programmers it’s easy to divide the tasks, each one might be responsible for a type of object and the class that handles it. Internationalization can be done using this technique, apply the proper class according to a language field selected by the user, etc.

Object Oriented Programming in PHP – Copying and Cloning

When you create an object $obj you can copy the object by doing $obj2=$obj, the new object is a copy (not a reference) of $obj so it has the state $obj had in the moment the assignment was made.

Sometimes you don’t want this you just want to create a new object of the same class as obj, calling the constructor of the new object as if you had used the new statement.

This can be done in PHP using serialization and a base class that all other classes must extend.

Entering a Danger Zone

When you serialize an object you get a string which has a certain format, you may investigate this if you are curious. One of the things the string has is the name of the class (nice!), you can extract it using:

<?php

$herring=serialize($obj);

$vec=explode(‘:’,$herring);

$nam=str_replace(“””,”,$vec[2]);

?>

So suppose you create a class “Universe” and force that all classes must extend universe, you can define a method clone in Universe as:

<?php

class Universe {

function clone() {

$herring=serialize($this);

$vec=explode(‘:’,$herring);

$nam=str_replace(“””,”,$vec[2]);

$ret=new $nam;

return $ret;

}

}

Then:

$obj=new Something();

//Something extends Universe !!

$other=$obj->clone();

?>

What you get is a new object of class Something created the same way as using new; the constructor is called, etc. I don’t know if this is useful for you but the Universe class which knows the name of the derived class is a nice concept to experiment with. The only limit is your imagination.

Note: I’m using PHP4, some of these examples may not work in PHP3.

Many programming languages are object-oriented. However, the method of defining an object varies from language to language. Some examples of object-oriented languages are:

• Java
• JavaScript
• C++
• and finally, PHP

Basic Class Programming in PHP

In PHP, an object is defined as this:

class myObject {
    //variables and methods go here
}

Methods are easy to add to classes. If you wanted to add a function to myObject that returns the current server time, you could do this:

class myObject{
	function getServerTime() {
		return time();
	}
}

Easy as that. Defining variables is a little bit trickier. There are many ways to define variables, but we’ll keep it simple for now and use the ‘var’ method.

class myObject {
        //this is a valid assignment
	var $variable     = 'constant value';

        //this is invalid because it is assigning to a function. This can't be done.
	var $serverTime = time();
}

To access internal variables, we have to use the $this variable. $this is a pointer that points internally, so that we can access the variables we just declared. So, we’re going to add a function to ‘myObject’ and access $variable.

class myObject {
        //this is a valid assignment
	var $variable     = 'Hello World!';
	function GetVariable() {
		//notice how there is no dollar sign $ in front of the variable
		return $this->variable; //this will return 'Hello World!'
	}
}

Notice how there is no dollar sign ($) in front of the variable we are pointing to with $this. This is also how you call methods internally.

On the last note of basic PHP classes, you will need to know how to create an instance of your class. Once you have created an instance of your class, you can use it in the same way you used ‘this’. To create an instance, use the method:

$instance = new ClassName();

This creates a new instance of the class ‘ClassName’. So, an example using everything we’ve learned:

class myClass {
	var $string = 'Hello World!';
	function ShowString() {
		echo $this->string;
	}
}
$instance = new myClass();
$instance->ShowString();

Also, it is entirely possible to create an instance of a class from a string:

class MyClass {
	function Exist() {
		echo "My class name is ".get_class($this)."
";
	}
}

$classname = 'MyClass';
$instance = new $classname();
$instance->Exist();
//this will echo 'My class name is MyClass'

That’s about it on a basic level! Now for some more advanced usage of classes.

Advanced Classes

Now that you know how to use variables, it’s time to learn about private and public variables. Basically, a private variable can only be accessed internally by the class itself; and a public variable can be accessed by everything. A variable you would want to keep private could be the password of a user class, for example. A public variable could be the title of the page. Public and private variables are very useful.

Here is a class that uses public and private variables:

class myClass {
	private $private_var = "This variable is private! You can't see this!";
	public  $public_var  = "This variable is public! Anyone can see this!";

	//note- you can also use public and private modifiers on functions
	//this is useful because internal functions should be private
	//and external functions could use more than one private function
	//it's good to make a network of public and private methods and variables
	public function PrintPrivate() {
		var_dump($this->private_var);
	}
}
$instance = new myClass();

//this line will print the contents of $private_var to the screen
//because it is being called internally using an external function of myClass
$instance->PrintPrivate();

//however, this line will print an error - private variables can't be accessed
//this is because it is being accessed externally
var_dump($instance->private_var);

When an instance of a class is created, the method (if it exists) $instance->__construct(arguments). So, with this knowledge, you should have realised that when calling:$instance = new myClass(arguments) the arguments are sent to the method __contruct inside myClass. This method is called a constructor. When an instance is deleted, the class destructor is called. The destructor is called when either every variable inside the class has been removed using the PHP function unset($variable) or at the end of the script.

class myClass {
	public $id;
	public function __construct($id) {
		$this->id = $id;
		echo "Constructed {$this->id}
";
	}
	public function __destruct() {
		echo "Destructed {$this->id}
";
	}
}

$count = 0;
$instance = Array();

//this line calls the 'construct' method and creates a new instance
$instance[$count] = new myClass($count);
$count ++;

$instance[$count] = new myClass($count); $count ++;
$instance[$count] = new myClass($count); $count ++;

This code will echo:

Constructed 0
Constructed 1
Constructed 2
Destructed 0
Destructed 1
Destructed 2

You can see that the constructor is called when the instance is created, and that the destructor is called when the script ends.

Now that we understand all of that, we can move on to…

Static Classes

So far, the classes have held variables, and have been individual instances. However, if, for example, you wanted a variable that had a set value and applied to all instances of the class, how would you do it? The answer is static variables:

class myClass {

 //the use of 'static' can be before or after 'public'
 //and it makes the variable global across the class
 static public $variable = 'Hello World!<br/>';

 static public function ShowText() {
 //for static variables, we use self:: instead of $this->
 echo self::$variable;
 }

 //notice that there is no constructor

}

//there is no need to construct a static class!
myClass::ShowText();
//this will output 'Hello World!'

//however, it is possible to create instances and use static at the same time
$class = Array();
$class[0] = new myClass();

//this is an invalid static function caller:
//$class[0]::ShowText();
//this will result in a parse error!

//this will work:
$class[0]->ShowText();
//it works because the function can be accessed
//statically and non-statically

$class[1] = new myClass();

//let's try something!
var_dump($class[0]->variable); echo "<br/>";
var_dump($class[1]->variable); echo "<br/>";
//these will both echo NULL because using ->
//as a pointer is incorrect!

$class[0]->variable = 'I\'m class one!';
$class[1]->variable = 'I\'m class two!';

$class[0]->ShowText();
$class[1]->ShowText();
//these will both echo 'Hello World!' because
//using -> as an operator will only change
//the class instance value of $variable
//which previously didn't exist.

//let's try changing it statically and echoing again!
myClass::$variable = 'This text has been changed!<br/>';
$class[0]->ShowText();
$class[1]->ShowText();
//these will both echo 'This text has been changed!' because
//the variable has statically been changed
//and this applies to all instances of the class

1. Obtain a copy of windows 7.

Official Microsoft Link – No more link your time for the official download is out

*You can also find a torrent of this but for legal reasons I cannot provide a link. *

2. Partition your disk

**This does go wrong in some cases, if in doubt back up your valuable data.**

Boot from a Ubuntu live cd or a gparted live cd.
Start up gparted, If ubuntu is on the whole disk you need to re-size it by at least 8 gb for Windows 7. (Make sure windows 7 is on the second partition to make it easier for grub) You will be left with some unallocated space on your hard disk if you want you can partition it to NTFS or you can do it later on the windows install.

3. Install Windows 7

Follow the on screen instructions, Select the un-partitioned space to format and install windows on, or if you already made it NTFS choose your NTFS partition.

**It will ask for a product key but you have 30 days to do that. Note: Beta keys will work with the RC**

4. Re-install GRUB

Now you have windows 7 but it has completely eaten your boot loader so you need to re-install grub.
Boot from the ubuntu live cd and go to terminal.
Type in terminal:

“sudo grub”
“grub> find /boot/grub/stage1″

That should return your Ubuntu partition in the form of (hdX,Y), use that:

grub> root (hdX,Y)
grub> setup (hd0)
grub> quit

(you don’t need to type the grub> bit)

That has re-installed grub but you can no longer see windows7

5. Edit grub.
Go to terminal from normal ubuntu and type :

“sudo gedit /boot/grub/menu.lst”

A large text file will open and at the bottom leave a line and add this:

title windows 7 beta (Loader)
root (hd0,1)
savedefault
makeactive
chainloader +1

(Do not type this line but if that does not work on re-boot try “hdo,0 or hd0,2” and so on until it works.)

Now that is done you can re-boot into windows 7 and ubuntu happily

The great thing about PHP is that you can do ANYTHING — really, anything, that can be done on the web by a website. You can do it very, very quickly, and usually with support from existing libraries. And it has been proven to scale horizontally, to the moon.

As for Ruby, it’s a cute language, I admit. I love the design of Rails (and have been using symfony PHP for a year now because of that.) I haven’t had a reason to try Python, but I certainly know Java and C# and ASP.NET pretty well. PHP is a much better choice for user-interface-oriented web programming. It simply reduces the amount of effort you need to accomplish your goal, and can still scale. Why is PHP just an easier way to get things done?

1.  useful, huge ecosystem with amazing sample code

2.  no-theory to get in the way of program logic. PRAGMATISM at it’s best.

3.  lightning fast edit-compile-test loop (edit-test)

4.  Easy to set up, scale, and migrate between infrastrucure

5.  it doesn’t put new and idiotic metaphors on top of the web — the web is it’s metaphor. (unlike, say, ASP.NET which is godawful)

6. Finding a server that runs PHP is very easy. Most shared hosts don’t support the other languages and you need to pay more to install it yourself.

6.  super-helpful associative arrays very closely mirror database-style data. I tend to recreate them in every language I use. There are things that PHP is not great at — systems administration, realtime services, embedded programming, whatever. But for plain old data-driven website, PHP never loses site of the simple fact — it’s just a freakin’ website. Get it done and move on!