There’s always been somewhat of a disconnect between designer-types and backend-types. And we’re not just talking about hairstyles, eyewear, and the contents of their bookshelves — designers and programmers approach problems in different ways, and their individual plans of attack don’t always jibe. Of course, you want your site to be sleek, fast, and bleeding-edge, but are you willing to compromise stability, scalability, and compatibility just so the users can ooh and aah at a few pretty pictures? Web design has always been a balancing act, and the ideologies of each camp often clash.

But Webmonkey’s here to say that it doesn’t have to be that way. It is possible to create a site that has a lightweight Flash frontend, a dreamy interface, and a scalable, secure, and dynamic backend.

Webmonkey Scott has found the balance between eye-catching design and backend database wizardry. Lucky for us, he’s agreed to share this knowledge in a two-day tutorial. He’s even put together a hands-on project that shows you how to build an easy-to-update blog using Flash. That’s right, a Flash-based blog — it sounds a little loony, but this blog pulls content from a MySQL database and feeds it into the dynamic Flash frontend using a few lines of PHP code.

In day one, Scott talks you through the construction of an open source MySQL database using both the phpMyAdmin tool and mysql on the command line. You’ll learn how to add blog entries to the database and then you’ll learn how to run queries in PHP. Topics such as basic database organization and the behavior of variables are also covered in this lesson.

Day two shows you how to design and build the blog’s Flash frontend. You’ll use common Flash ActionScript objects to pull the content from your MySQL database to the different areas of your blog’s user interface. You’ll also learn some common workarounds to keep all of your content flowing smoothly.

Whether you are designer or a programmer, it’s time to roll up those sleeves and get ready to see how the other half lives. Even if those of you who don’t feel a particular loyalty to either side of the fence will still discover that there’s plenty of hands-on knowledge to be gained.

We’re not promising that designers will sell their $500 pencil sharpeners, start marrying UNIX geeks, and honeymooning in Cancun before breeding programmer/designer children, but we will insist that they sit in a room alone together until they can build a useful website that everyone can agree on. Hey, stranger things have happened. Like Carrot Top.

Building with Flash and MySQL

From the beginning, the database has been the sole province of programming geeks. For designers, usually geeks themselves, but with backgrounds in color theory or animation rather than code architecture, the jargon surrounding databases is often confusing, overwhelming, and intimidating. Even so, the irony is that designers are sometimes the very people who can benefit the most from using a database.

Many designers can create eye-popping sites full of life, but it’s rare to find a designer who can sustain that initial vibrancy as the site ages. How often have you seen an amazing-looking site that was created, hyped, then abandoned?

Database integration can propel a website from a well-designed but infrequently updated bore to a dynamically generated, updated-on-the-fly extravaganza for the mind. Connecting your design to content driven by a database gives you or your clients a site that can be updated easily without ever needing to touch the design elements themselves. Also, this separation of content and container will make your job as a designer much easier. With the continuous flow of timely content from your easy-to-update database, your site will stay fresh and youthful. It works better than any of those creams from France, anyway.

As a good designer, you’re capable of translating loosely held, often ill-conceived ideas into the sites we all use and enjoy. What’s more you make them look good. But perhaps dealing with raw code is not your forte. Not to worry, it’s not as difficult as you might think.

To get the full benefits a database offers, we’re going to feed our content into a Flash movie rather than an HTML page. Why would you want to do that, you ask? As a seasoned Web surfer, you’re probably familiar with the so-called “blink” of HTML. The process goes a little something like this:You click a link, the link then sends a command (often via PHP, which we’ll use here) to a database to retrieve whatever information you’re after. Once the database has retrieved your information, it sends that info back to the page that requested it. Now, if that page is HTML, your browser must weed through the results and shape them accordingly. But, before it can do any of that, the browser must first empty out the old page and create that momentary blank browser window – the blink of HTML.

This doesn’t happen with Flash. Flash can load the data into the very same place from which it was requested without a visible refresh. No blink. No redrawing of elements that haven’t changed. In short, a smoother, less distracting transition for your user which leads to a better, more enjoyable viewing experience.

Everybody convinced? Then let’s get started.

PHP Basics

If you’ve worked with databases before, even if you’ve always fed the content into HTML pages, you’ll have a head start here. I’ll be assuming that you have MySQL and PHP installed and running on your server. If you’re going to be doing this through your Web hosting company, check to see if they already have the necessary software installed. If you find that you need to install either program, check out PHP and MySQL Tutorial, which will also be a helpful read for those of you who’ve never worked with PHP since it goes into a little more detail on the syntax. The homebase for MySQL has a full manual available for download, as does the official PHP site. Take advantage of these free resources. Many hardworking volunteers have created them for you, and answers to most nitty-gritty questions can be found on one of those sites.

If your website is hosted by someone other than yourself, you will have to ask your hosting company how to connect and interact with your database. Most good hosting companies will have you interact with your database via your Web browser and the phpMyAdmin program. The application will give you a nice graphical interface for creating tables and entering information. Also, phpMyAdmin shows you the actual MySQL syntax for your actions, which will let you get a better feel for how MySQL works. Really good hosting companies will let you connect directly via a secure shell or some other graphical program of your choice.

There are many other graphical ways to interact with MySQL, but for the purpose of this tutorial, I will be giving examples from a terminal interface using the mysql client program, which comes with the MySQL package.

Why use a terminal when GUIs of all shapes and sizes are available? Graphical interfaces may allow you to interact and manipulate data, but they often do so without letting you understand exactly what it is you’re doing. Typing the commands in a terminal session will help you not only learn the SQL syntax but understand how and why you’re doing what you’re doing. Knowledge of the SQL syntax will give you a better understanding of how to use PHP to manipulate SQL data. And what are you going to do when you land that dream project you spent months pitching only to learn you aren’t going to have access to a GUI? Over-reliance on GUIs is not the monkey way. Don’t let the command line intimidate you.

To take full advantage of the organization a database offers, it helps to sit down ahead of time with a pen and piece of paper (made from trees … or even better, recycled material … like in high school) and plan out your database. Databases are simply means of organizing information into tables. Tables are made up of columns and rows. Typically each vertical column is some category of information and each horizontal row is an individual instance of that information. Too abstract? Think of your monthly bank statement. If it’s anything like mine, it’s a simple table (full of zeros). Across the top are column definitions (check number, payee, amount, et cetera). Reading horizontally, each line contains values that are given meaning by the column they’re in. MySQL databases work very much the same way. We create tables, define columns, and enter rows of data. The main difference is that our information will be searchable by any criteria we define.

Unfortunately, those MySQL searches cannot be run directly from your browser. Thus, while we can enter the commands and search in our terminal (or GUI bad monkey, no banana), we can’t write some HTML code and duplicate those search results. But that’s OK, because there are other languages that can duplicate them. The two main languages used in a database search, or query, are PHP and Perl. For our purposes, which will be to deliver Web content to Flash, we’re going to use PHP. PHP was developed to specialize in database connections on the Web.

Chances are many of the sites you visit everyday are generated using PHP. You’ve been seeing the benefits without ever knowing what was going on behind the nicely formatted information you receive. How did PHP give you your information without you even knowing it was doing so? If you view the source of a PHP page you will only see HTML. Where the heck is the PHP and how does it do what it does? We’ll get to that part a little later. Right now let’s dive into MySQL and feed it some information.

Using MySQL

Databases are serious stuff my friends, and databases call for serious examples. When I think of seriousness and integrity on the Web, the first thing that comes to mind is the weblog. Ahem.

Anyway let’s suppose you’re one of the two people who don’t yet have a blog. Or even better, let’s suppose you want to create a weblog that’s a little different from the endlessly repeated templates you see everyday. Let’s suppose for a moment that you want to create your very own Flash-based weblog to tell the world about your ever-growing collection of florescent feather boas or your serialized, Charles Dickens-style Great American Novel (Great British Novel just doesn’t have the same ring, sorry). Whatever it is, you plan on telling the world something about it each and every day.

Well then, let’s think about this for a moment. Your user interface will be a Flash .swf file that will display content from your MySQL database. How do you want to organize your data? That’s really up to you. The simplest approach is the date-based model that most weblogs out there function on:one date, one title, one entry. Our simplest case calls for a table that contains the following information:

Before we run off to create this table, let’s first look at some potential problems with our mock-up (remember: measure twice, cut once). While this table meets our most basic needs, we might want to include a few other things. Let’s say for instance that down road, when we get more sophisticated with our site, we want to be able to search according to subject. Well, right this minute we aren’t going to bother with a subject column, but in the future we might want to add a whole separate table to contain metadata of this sort. To link a new table to this one we’d need an index column. So our mock-up should include an ID column which will cover us if we’d ever like to add to our database. We’ll also be using the ID column to simplify the process of finding the newest entry.

Alright, we’ve done all of our paperwork. Our database-to-be looks pretty robust, so let’s go ahead and create it.

Creating the Database

For this example, I’m going to assume you’re using the mysql client (note the all lowercase mysql, this denotes the client program that comes free with MySQL) in the command line. To fire up the mysql client, start up a new terminal window and login to your server using the format:/Path/To/mysql/ -h yourHostname -u yourUser -p. Enter your password when prompted. Now we’re going to issue the following commands (and don’t forget your semicolons):

mysql> CREATE DATABASE blog_db;

This command tells MySQL to create a new database named blog_db (you can give it whatever name you like, just adjust everything accordingly). Now switch to the new database.

mysql> USE blog_db;

You can verify that you’re actually using the blog_db by issuing a SELECT DATABASE() command which will tell basic information about our newly created blog_db database, namely, that it contains nothing. An empty database is a useless database, so let’s create a table. Your input will look like this:

CREATE TABLE blog_entries (



 id INT NOT NULL AUTO_INCREMENT ,



 date DATETIME NOT NULL ,



 title VARCHAR (30 )NOT NULL ,



 entry LONGTEXT NOT NULL ,



 PRIMARY KEY (id)



 );

OK what the hell is all that gibberish? Let’s walk through it one statement at a time.

The CREATE statement should be obvious:It creates a new table by the name of blog_entries. Next, we fill out our table. But we don’t want just a table, we want to define our four columns that we’re going to use to organize our data. So, “id” is the first column and will be an integer, defined by INT(). The NOT NULL statement simply means that each row must have a value for this column. As you can see, I’ve set the table up to require values for all the columns. If you need some rows of a table left blank, simply change the statement to NULL which will allow blanks, or “null values” in database speak. The AUTO_INCREMENT statement tells MySQL to assign a new value for each row and to increment that number each time we enter another row. In other words, the first entry will get a value of 1, the second 2, and so on. This way, we don’t have to keep track of what entry number we’re on; we let MySQL do it for us. This will allow us to always find the most recent entry by querying for the largest number. This information will come in handy when we start writing queries in PHP.

Next is DATETIME, a predefined format that will have MySQL stamp each entry with the current date and time. VARCHAR, on the next line, is short for variable character. This means that entries in the title column will be filled with characters of varying length. I chose to cut them off at 30 characters, but you can specify any number you’d like (up to 255). The last datatype we’re using is LONGTEXT. LONGTEXT allows up to 4,294,967,295 characters. That’s over one million words per entry — possibly overkill for our purposes, but I thought we’d play it safe. You could also use MEDIUMTEXT if you’re feeling less wordy than me. PRIMARY KEY is somewhat more complex, and I’m not going to explain it here, other than to say that if a column is AUTO_INCREMENTed it must be a primary key.

Whew! Alright, just to make sure that MySQL created things the way we expect, issue the command DESCRIBE blog_entries and you should see the following:

Notice the date format is year-month-day. Putting the year first takes some getting used to, but this is how MySQL handles dates — you’re just going to have to keep that in mind. We’re good monkeys, flexible and capable of adaptation.

Entering Data

Okay, we have our table all set up. Now we just need to enter some data. Entering information into MySQL can be very laborious when done by hand. For this reason, extensions were written to read from tab-delimited text files. However, since our table is pretty simple, and it’s unlikely that we’ll be entering more than one row at a time, I’m going to go ahead and enter things the old fashioned way. When your data gets more complex, you’ll want to investigate how to enter from external files. A good starting point would be the MySQL site.

 INSERT INTO blog_entries VALUES



 (



 '',NOW(),'my first blog entry','your text here'



 );

The main thing to notice here is that the first value is blank. The value for the ID column tells MySQL to go ahead and insert the auto increment number, in this case, the integer one. The NOW() function gives us the current date and time. If you wanted to forge an older or newer date and time, you could enter them by hand in the format discussed earlier (YYYY-MM-DD 00:00:00). Double check to see that everything looks the way it should by issuing your first real query:

SELECT * FROM blog_entries;

and you should see:

I went ahead and inserted a few more entries to give us more to play with when we get to the Flash end of our blog. See, that wasn’t too bad was it? Alright, maybe a little, but take a deep breath and move on to the PHP anyway.

Add a Dash of PHP

When a user arrives at our blog, we want the following two things to happen:First, we want the latest entry to be displayed. Second, we want to display a list of past entries, which will be links to our older postings. I’m going to make the archives show both entry and date so you can see how both methods would work. The information we need to retrieve is stored in our table named “blog_entries”, which is part of the database named “blog_db”. The Flash piece we’re going to build will need to query the database for that information, and to do so, we will utilize a PHP file.

If you’re familiar with Flash ActionScript, PHP should look familiar to you. Like ActionScript, PHP is a scripting language and therefore has a similar syntax. The one big difference from ActionScript is that PHP variables must always begin with a $. Just like in Actionscript, we’re going to write some functions and use them to interact with our blog_db database. The reason I spent so much time on the MySQL section is that the commands we used there to see the entries in our database are the same as the ones we’ll use in our PHP scripts. For our purposes, PHP is going to act as a middleman, sending queries from Flash to MySQL and then returning results back from MySQL to Flash.

So, diving right in. Fire up your favorite text editor, create a new document and save it with the extension .php. Now enter in the following code. (Your browser will probably wrap this code, so try copying the raw source)

<?php

mysql_pconnect ("yourHost", "yourUserName", "yourPassword");



mysql_select_db ("blog_db");

$qResult = mysql_query ("SELECT * FROM blog_entries ORDER BY id DESC");



$nRows = mysql_num_rows($qResult);

$rString ="&n=".$nRows;





for ($i=0; $i< $nRows; $i++){

	$row = mysql_fetch_array($qResult);

	$rString .="&id".$i."=".$row['id']."&"."&title".$i."=".$row['title']."&"."&date".$i."=".$row['date']."&"."&entry".$i."=".$row['entry']."&";

}

echo $rString."&";



?>

Now let’s go through it line by line. The first few lines are PHP’s way of connecting to our database, just like what we did earlier in our terminal program. How does this work you ask? PHP, like ActionScript, has a bevy of built-in functions, and one of them is mysql_pconnect(). So then it’s just a matter of plugging in the right parameters for our database. The mysql_select_db() function is just like the USE function we typed earlier in our terminal. It tells MySQL which database we want to query. Then we have these lines:

$qResult = mysql_query ("SELECT * FROM blog_entries ORDER BY entry_id DESC");



 $nNows = mysql_num_rows($qResult);



 $rString = "&n=".$Nrows;

Here we’ve created three variables (remember variables in PHP must begin with a $). The variable $qResult is our actual query to the database (qResult is short for Query Result — get it?). The parameter is a string which tells MySQL to select all the information in our blog_entries table and return them in an ordered list. The ORDER BY command will order our result by the id column, starting with the largest number and reading down in descending order. This means that the rows of data returned start with the newest entry and read down to the oldest. Now you can see why we used the auto increment feature when we set up our table.

The variable $nRows uses the function mysql_num_rows() to store the number of rows in our database (nRows is short for number of rows). We need to know how many rows we have so that we can write a loop to cycle through and read each row. Then we will write some code to format each row into a URL encoded string, which we will then pass on to our Flash movie. $rString is the variable we will use to pass the data to Flash (rString being my shorthand for Returned String). Next comes the loop to read all the data in our table.

for ($i=0; $i< $nRows; $i++){



 	$row = mysql_fetch_array($qResult);



 	$rString .="&id".$i."=".$row['id']."&"."&title".$i."=".$row['title']."&".



 	"&date".$i."=".$row['date']."&"."&file".$i."=".$row['entry']."&";



 }



 echo $rString."&";

“Oh my god!” you scream, “What is that string of nonsense?” Good question.

The first thing we’ve done is set up a for loop. This loop says:for a variable $i, which is initially equal to zero, and for as long as $i remains less than our variable $nRows, increment the variable $i by one each time you perform the following loop. We do this so that PHP will loop through each row of our MySQL table and give each row its own unique number. This way when we pass the information to Flash, we can separate each entry and send it to the appropriate place.

Next, we’ve taken advantage of another built-in PHP function (don’t worry — it won’t sue). We’ve created the variable $row and assigned it the function mysql_fetch_array(). Our parameter is the variable $qResult which we defined earlier as our query. This function takes the long string of information that is our variable $qResult and breaks it into an array. The new array contains all our table columns and the rows of data. Using the $row array we can access each element by name. Let’s just pause for a moment and consider that there are brilliant programmers out there who made this possible with one simple line of code.

Done pausing? Great, let’s move on.

Strings, Sealing Wax, Fancy Stuff

OK now let’s concentrate on that really long and confusing line, the meat of our for loop. It turns out that Flash has to receive external information in the form of a URL-encoded string (actually, if you install Flash Remoting on your server, it can receive information as straight record sets, but Flash Remoting is beyond the scope of this article — visit the Macromedia site if you’re interested in learning more). The string our Flash movie will be looking for is a bunch of incremented variables squeezed between ampersands. If we include linebreaks to make it more readable it looks like this:

&id0=1&



 &title0=myfirstEntry&



 &date0=2003:10:10 03:30:02&



 &entry0=some text&

The variable $rString in our PHP code contains all the necessary formatting syntax to ensure that Flash gets this string. The PHP code looks confusing because we’re concatenating (joining together) strings (everything in quotes) with elements in our $row array.

Let’s break it down some more. In PHP we write (I’ve put extra spaces between each element to make it easier to follow):

 $rString.=  "&id".  $i.  "=".  $row['id'].  "&"  et cetera...

$rString is our PHP variable which will get passed to Flash. We’ve assigned it to a big long concatenated string of smaller strings and elements of the array $row. In PHP the . (dot) operator is used to concatenate elements of a string. “&id” starts our string off and gets joined with the variable $i. Now the variable $i is the incremented element in our loop, so it will be an integer. Because we set $i=0 in our loop, the first time through the loop it will be 0, the second time it will be 1, and so on. For this reason, each row in our MySQL table has a unique identifying number. We then join the $i variable with an equals sign. So far we have given Flash the following information:

 &id1=

Now we assign this newly created “id” variable an element in our $row array ($row[id]). Essentially we’re writing id=id, pretty simple right? The first number in our MySQL column was 1, so the first time through our loop we return a 1. We then tack on another string so that this element of our big string (the one being passed to Flash) is enclosed in ampersands the way we want it to be. All Flash is going to see is:

 &id1=1&

The rest of our variable $rString does the same formatting for the rest of our columns so that we can pass Flash our completed string which will look like this:

 &id0=1&&title0=myfirstEntry&&date0=2003:10:10 03:30:02&&entry0=some text&

Now for the final and really easy bit of code:

echo $rString."&";



 ?>

Since Flash is going to read the results of our PHP code, we have to make sure that we use the echo command, to tell PHP (when it gets done processing all the things we’ve told it to do) to display the completed string shown above. Echo is the same as print. In fact, you can use the command print if you so desire. The ?> simply closes our PHP code just like  /html¢ would close an HTML document.

To test and make sure everything is working, upload the .php file to the server and point your browser to its location. You should be greeted by a stark white page with unformatted black text that reads:

 &id0=1&&title0=myfirstEntry&&date0=2003:10:10 03:30:02&&entry0=some text&

Okay, you’re done. With PHP that is. Time for a break. Crack your knuckles, lean back, smoke ‘em if you got ‘em, and relax. That was some terribly complicated stuff you just waded through.

A quick note about security:Did it make you nervous to type your password in plain text at the beginning of our PHP file? It should. Granted, PHP is a server-side technology and there is no easy way to view this file as we’re seeing it. But that doesn’t mean it can’t be done. A more secure method of sending this information is to use an include statement. What we do is take the mysql_pconnect statement and move it to a separate file. Name it connect.inc, and now move it to a location on your server where the general public can’t access it. Then change the mysql_connect statement above to read include (“connect.inc”). Also, don’t forget to tell PHP where the include file is. We need to edit the PHP initialization file to point to the directory in which you just placed the include file. Typically, the initialization file lives in the /usr/local/apache/php directory. If your server isn’t running Apache, refer to your documentation. Not only is this method more secure, it saves you from having to type the whole connect statement every time you write a new PHP document for this database.

Now rest up and get ready for lesson 2!

In Build a Website With Flash and MySQL – Lesson 1, we successfully created a MySQL database, filled it with blog entries, and learned how to query it. Now we’re going to move on to the fun stuff:creating a Flash container to display our blog entries as we pull them out of the database. I’m going to help you build something along the lines of what you’ll encounter at my own Flash blog site, Luxagraf.

Fire up Flash and create a new document. The first thing we need is a nice big text field to display our entries. You could create a text field in ActionScript if you like, using the createTextField() method. I don’t know about you, but my stomach for code is still full from yesterday, so I’ve just drawn a text field using the cursor tool and given it an instance name of entries_txt. In the Properties Inspector, set the text to be dynamic, multi-line, and HTML formatted. For safety’s sake, select the character option and click “embed all characters.” Flash has some issues with dynamic textfields that don’t have embedded characters, especially if you put your text under a mask.

I’ve also attached a scrollbar to the text field and given it an instance name of sb.

My design is minimalist, but you can load up your movie with cool graphics, nifty background animation, menus, and more. And you can rest assured that while Flash is retrieving your data, your design will keep your user otherwise enthralled until the data loads. You might even include a loading progress bar if you want to give modem users some feedback so they know that something is happening. Creating a progress bar for external data is a little more complex than one for an external .swf, but it’s not too bad. Colin Moock, author of ActionScript:The Definitive Guide, has a sample available.

To show our list of archived entries, we’ll need a second, smaller text field, which I’ve named archive_txt. I’ve attached another scrollbar to the archive text field and given it instance name sb2. Set the archive text field up the same way:dynamic, multiline and HTML. You don’t need to embed the font again since it can use the characters from the first text field.

That’s it for the graphics. Now let’s get back to code!

Linking Flash to the Database

Create a new layer on top of the last one and name it “actions” or something similar. Now open up the Actions panel (F9) and paste in the following code. It should display correctly below, but if your browser refuses to wrap text properly, use the plain text or HTML version of the raw code.

//function to load external data using the loadVars() object

//l=name of loadVars object

//n=name of text field

//t=trigger to decide whether to show all entries or just one.

//e= entry number to display (number)

//f=file to load from (string)

function lv(l, n, t, e, f) {

	sb.setSize(null, 200);

	sb2.setSize(null, 50);

	//create a new loadVars object if one doesn't already exist

	//if it does, use it

	if (l == undefined) {

		l = new LoadVars();

		l.onLoad = function() {

			var i;

			//clear out any text that might already be there

			n.htmlText = "";

			//to show a single entry at a time we use the

			//following code

			if (t == undefined) {

				n.htmlText += "<b>"+this["title"+e]+"  -

				"+this["date"+e]+"</b><br><br>";

				n.htmlText += this["entry"+e];

			} else {

				//cycle through and show all entries

				for (i=0; i<this.n; i++) {

					n.htmlText += "<u>

					<a href='asfunction:_root.loadArc,

					"+this["id"+i]+"'>"+this["title"+i]+"  -

					"+this["date"+i]+"</a></u><br>";

				}

			}

			sb.update();

			sb2.update();

		};

	}

	l.load(f);

}

What we have here is a reasonably generic function that you can use to load external data in any Flash movie provided you know how it works and how to modify it. I’ll walk you through it line by line and hopefully you can see where you might have to change things to suit your needs.

First off, let’s define our single letter variables in a little more detail. First we have “l”, which will become a new instance of the loadVars() object. The object needs to have an instance name so we’ll give it one when we call the function. Next we have “n” which will be the name of the text field. If you’re following along with my example, we’re going to use the instance name of the text fields we created earlier (entries_txt and archive_txt). By making this a variable that’s passed to the function, we can create as many textboxes as we want and we don’t have to rework our main loadVars function. “t” is for trigger (like the horse, but smaller). This variable may be unnecessary for your needs, but I’ve put it in there so that I can use the same function to load both the main text and archives. For the main textfield, I’ll pass a value of undefined because I only want to show the latest entry. For the archive textfield, we can pass any value other than undefined. In my own work I tend to pass the string “cycle” so I know what it is I’m doing without looking back at the actual function, but you could pass it the string “webmonkey rocks” and it would do the same thing.

The next variable is “e,” which we won’t be using initially, but which will help us when we get to the archive section by allowing us to select entries by number. Last we have “f”, which is short for file, as in the .php file we’re calling. In the last section, use whatever name you used when you saved your .php file. I chose blog.php.

It’s worth asking why I didn’t use more descriptive variable names in the function. Well, that’s partially due to laziness, but it’s also because using single letters seems to make things happen a bit faster.

Loading Up on Content

Okay, now that we’ve spelled out our variables, we’ll move on to the function and its inner workings. To load our database information into Flash we’re going to be using the loadVars() object. As with most Flash objects, the first step is to create a new instance of the object. In this function we’ve started with an if statement.

 if (l == undefined) {



 		l = new LoadVars();

The if statement checks to see whether we have a loadVars object by the name of “l” and, if not, it creates one. Now, since “l” will be defined in our function call, we can create loadVars objects left and right if we want to. On the other side of the coin, if we already have a loadVars object by the name we’ll call, we don’t have to waste time creating a new one. The next thing we need to do is define the onLoad method of our loadVars() object. Flash needs to know what to do with the information it’s about to get. So we define the function to process our data. Here’s the section of the code from page two that we’re dealing with:

l.onLoad = function() {

			var i;

			n.htmlText = "";

			//to show a single entry at a time we use the

			//following code

			if (t == undefined) {

					n.htmlText += "<b>"+this["title"+e]+"

					-  "+this["date"+e]+"</b><br><br>";

					n.htmlText += this["entry"+e];

			} else {

				//cycle through and show all entries

				for (i=0; i" +this["title"+i]+"

					-  "+this["date"+i]+"</a></u><br>";

				}

			}

The first thing in our function is a variable i. I should point out here that, just as we used $i in our PHP code, we’ll call this variable i as well. Using i for incremented variables is just a programming convention. If there is a good reason for it, I’m not aware of it. You can ignore convention and use whatever you like, just don’t use any of the letters we’ve already assigned. The key thing to note is the use of var to define the variable. In Flash, var creates a local variable; that is, the variable i is only defined in this function. Outside this function you can use i again and it won’t mess things up. Local variables, as this practice is called, use up less memory since they get used and wiped away immediately afterward. Next we empty out our textfield:

n.htmlText = "";

Now we’re going to set up two possible ways of handling our data using our “t” variable as a selector. The code reads “if the variable t is undefined then do the first chunk of code, else do the second chunk of code.” The first chunk of code is just formatting for the information that was passed from MySQL. Our variable n, which will be the name of our text field, gets its htmlText property defined.

 n.htmlText += "<b>"+this["title"+e]+"  -  "+this["date"+e]+"</b><br><br>";



 n.htmlText += this["entry"+e];

Here we’re concatenating a string again like we did in PHP, except in Flash we concatenate strings with the + operator. The first element is an HTML bold tag to highlight the title. The title itself comes from the array we defined in PHP this["title"+e]. “This” refers to the function we’re in, which is the onLoad handler, meaning anything with the “this” designation uses the PHP passed data. So, this.["title"+e] refers to the title column in our MySQL table plus our variable e. We could have just said this.["title"+0], but then we wouldn’t be able to use this function in our archives section. Next we have a dash to separate the title and date. Then, we join the rest of the string which is the same code, but this time we use the “date” element of our PHP array. Lastly, we close the bold tag and add some
tags to put a little space between the title and the entry itself. The entry itself is written on a separate line so it will be displayed below the date and title. Once again we use an element of the PHP array, this time the “entry” element, which contains the main text.

But what about our other case? Can we display a list of past entries listed by title and date without text? Of course, but first let’s look at how our function will get to this point. If we define the variable t, the if statement we just wrote evaluates to false so Flash jumps to the else clause. The else clause then tells Flash to execute a loop so all of our entries will be displayed at once. Remember for loops? Well this one should look familiar from the PHP section. It’s essentially the same loop with one subtle difference:the second condition, iThe way we’re handling the data in the archives textbox is a little different, too. We’ve set our text to underline using the HTML tag <u> and wrapped everything in an HTML link (note that this should all be on one line with no hard returns).

 n.htmlText += "<u><a href='asfunction:_root.loadArc,"+this["id"+i]+"'>"



 +this["title"+i]+"  -  "+this["date"+i]+"</a></u><br>";

Our href tag might look a little strange to veteran HTML coders. Flash has a little-known feature that allows you to call a function from within an HTML tag. The syntax is asfunction:location/nameOfFunction,variable. The limiting thing is that you can pass only one variable using this method. The quickest way around that problem is to pass a variable as long string and then break it apart in your function, but that won’t be an issue for us since we have only one variable to pass.

The last line our onLoad function uses the variable “s” to update our scrollbar. The lines after our onLoad function call the .load method of the loadVars object and pass the name of our .php file. This tells our loadVars object to go ahead and read the .php file. It might seem backwards to define the onLoad handler before calling the load function, but you must define the onload handler first.

Publishing the Finished Product

Alright! We’re so close, I can taste it. Now that we’ve written our main function, let’s handle that asfunction we’re calling to, but haven’t yet defined.

Copy this code into your Flash movie:

 function loadArc(passed) {



 	arcNum = passed-1;



 	lv(blog_lv, entries_txt, undefined, arcNum, "blog.php");



 }

All this function does is take the entry number passed from our lv function, subtract 1, and then call the lv function again with the new number. Why subtract one? Remember that our PHP loop starts counting at zero, but our MySQL auto increment starts at one. This means we’re always one number behind. Simple solution to the problem:subtract one.

More copy and paste:

 //for the large entry textfield



 lv(blog_lv, entries_txt, undefined, 0, "blog.php");



 //for the archives text field



 lv(archive_lv, archive_txt, "cycle", null, "blog.php");

These lines call the function lv with all of our variables defined. When this code gets executed Flash will jump up and read our lv() function and then look for our PHP file which will query our database, extract and format our information and send it back to Flash where it will be displayed. I know it sounds like an incredibly long and complex process, but it will actually happen in fractions of a second and your user won’t have to sit idly waiting for the entire page to redraw itself.

OK, publish the movie and upload it to your site. You’re done! Now, when a user comes to the site and loads the Flash piece, they’ll see the latest entry in the big text box and a list of past entries in the smaller one. Try clicking on the links in the archive list. You should see the Flash movie bring up past entries in the larger text box.

You can see a working version of this very system over at my own blog site, Luxagraf. While you’re poking around, click on the “Browse Archives” tab at the bottom of the Flash window and you’ll see my second textbox full of archived entries show up.

We did it! Primitive though it may be, we’ve created a Flash-based blog and learned a few things about Flash and database integration. Now let’s take a look at some places we can expand our code and make it more useful to a wider range of applications.

Allow Me to Extrapolate

My main goal with this tutorial was to give you, the designer/programmer (which you can now truthfully call yourself!) a starting point from which to extrapolate and expand. You’ve made it this far, and for that you should be proud, but you probably have some questions. With this in mind, I wanted to address a few things.

First off, we only scratched the surface of MySQL and PHP. To start thinking in more general terms, I suggest visiting the developer’s sites for the two technologies. Perhaps you should also join some mailing lists and see what others are doing with MySQl and PHP. Since there is no way to sit back and anticipate what a particular project may require, it’s a good idea to look around and see how other people are using these tools.

Some examples that spring to mind for PHP/MySQL projects are a discussion board, or perhaps a backend application that lets your client update content without having to access MySQL directly. Once you have a better idea of what you can do with a database and have polished up your PHP knowledge, you will start to see some holes in our example. For instance, what if your want your PHP query to be dynamic? Suppose you want to return a query based on user input (i.e. some sort of search criteria defined by the user)? It’s not hard to do that at all. From the Flash end, you simply need to use the sendAndLoad() method of the LoadVars() class rather than the simple load() method (look it up in the ActionScript Dictionary) and then write your PHP query string with a POST variable. PHP and Flash are both very flexible tools, and you’ll find that the functionality you can achieve by using them is close to unlimited.

The final concern I wanted to address is Macromedia’s release of Flash MX 2004. Aside from the fact that software manufacturers seem intent on coming up with ever more confusing product names and pricing schemes, the more pertinent question is “Does our example still work?”

The short answer is yes. Judging from my own experience with Flash MX 2004 Professional and the Flash Player 7, the behaviors associated with loadVars() remain the same. There is, however, a new set of data components in Flash MX 2004. I have not explored these new tools in great depth, but it’s very possible they may simplify the code necessary to access external data sources. In my readings, the new components seem to be geared toward moving data between component sets. However, there is a fair price to be paid. Just dragging the new dataGrid component onto the Flash stage is going to bump your file size up by 58Kb. In comparison, the code we’ve written is only as large as the scrollbars you use. It’s also worth noting that none of these components can query MySQL directly – several rather expensive server technologies are supported, but not the free, open source solution.

This raises yet another issue:By no means is Flash limited to PHP and MySQL interaction. Everything we’ve done can be done with ASP or other proprietary software so long as you know how to get the returned data into a URL encoded string. Then there is XML data which is also not hard to feed into Flash…

Hopefully this tutorial can serve as a kind of gateway, providing an entrance into the world of dynamic content for Flash movies. How much of it you use is always going to depend on your own projects and needs. If nothing else, you have left the five percent nation of non-weblog creators and joined the thronging masses. Now take this project and see if you can adapt it to your own creative needs.

In this lesson, we’re going to dive right in and create some simple yet useful pages using PHP and MySQL. Let’s start by displaying the database we created yesterday in Lesson 1, but with a little more panache.

First, let’s query our database using the following code.

 <html>



 <body>



 <?php



 $db = mysql_connect("localhost", "root");



 mysql_select_db("mydb",$db);



 $result = mysql_query("SELECT * FROM employees",$db);



 echo "<table border=1>n";



 echo "<tr><td>Name</td><td>Position</tr>n";



 while ($myrow = mysql_fetch_row($result)) {



 		printf("<tr><td>%s %s</td><td>%s</td></tr>n",

 		$myrow[1], $myrow[2], $myrow[3]);



 }



 echo "</table>n";



 ?>



 </body>





 </html>

You probably noticed that we introduced a couple of new features here. Most obvious is the while() loop. The loop says that as long as there are new rows of data to be grabbed (using the mysql_fetch_row() function), assign that row to the $myrow variable. Then execute the instructions between the curly brackets ({}). Take a look for a second, and this should make sense.

The mysql_fetch_row() function bears a closer look. One small problem with mysql_fetch_row() is that it returns an Array that supports only numeric references to the individual fields. So the first field is referred to as 0, the second as 1, and so on. With complex queries this can become something of a nightmare.

Now let’s examine the loop in more detail. The first few lines you’ll recognize from the example in * lesson 1 . Then in the while() loop we fetch a row from the result and assign it to the array $myrow. Then we print the contents of the array on the screen with the printf function. After that it loops around again, and another row is assigned to $myrow. It will do this until it runs out of rows to grab.

The great thing about a while() loop is that if your query returns no records, you won’t get an error message. The first time through there won’t be any data to assign to $myrow, and the program will just move on.

But if the query returns no data, we have no way of letting the user know, and we should probably provide some sort of message. This is possible, so let’s do it.

Stay Informed

Take a look at this script.

 <html>



 <body>



 <?php



 $db = mysql_connect("localhost", "root");



 mysql_select_db("mydb",$db);



 $result = mysql_query("SELECT * FROM employees",$db);



 if ($myrow = mysql_fetch_array($result)) {



   echo "<table border=1>n";



   echo "<tr><td>Name</td><td>Position</td></tr>n";



   do {



     printf("<tr><td>%s %s</td><td>%s</tr>n", $myrow["first"], $myrow["last"], $myrow["address"]);



   } while ($myrow = mysql_fetch_array($result));



 	echo "</table>n";



 } else {



 	echo "Sorry, no records were found!";



 }



 ?>



 </body>



 </html>

There are a number of new features introduced here, but they’re quite simple. First, there’s the mysql_fetch_array() function. This is exactly the same as mysql_fetch_row() with one nice exception:Using this function, we can refer to fields by their names (such as $myrow["first"]) rather than their numbers. This should save us some headaches. We’ve also introduced a do/while loop and an if-else statement.

The if-else statement says that if we can assign a row to $myrow, then continue; otherwise skip to the else section and do what’s in there.

The do/while loop is a variation of the while() loop we used on the last page. We need the do/while loop here for a very good reason:With the initial if statement, we assigned the first row returned by the query to the variable $myrow. If at this point we executed a regular while statement (such as while ($myrow = mysql_fetch_row($result)), we’d be kicking the first record out of the variable and replacing it with the second record. But the do/while loop lets us test the condition after the code has been run once. So there’s no chance of us accidentally skipping a row.

Finally, if there are no records returned at all, the statements contained in the else{} portion will be executed. To see this portion in action, change the SQL statement to SELECT * FROM employees WHERE id=6 or something else that will return no records.

Now let’s extend this looping and if-else code to make one fancy-schmancy page. You’re going to love it.

Link Intelligently

We’re going to take that looping power we just learned and use it in a more practical example. But before we proceed here, you should know how to work with forms, the querystring, and the GET and POST methods.

Right now I’m going to work with the querystring. As you should know, there are three ways to get information into the querystring. The first is to use the GET method in a form. The second is to type the information into the URL on your browser. And third, you can embed a querystring in a standard link. Just make the anchor tag look something like this:<a href=”http://my_machine/mypage.php3?id=1“>. We’re going to use this technique right now.First off, lets query our database again and list the employee names. Look at the following script. Much of this should look pretty familiar by now.

<html>



<body>



<?php







$db = mysql_connect("localhost", "root");



mysql_select_db("mydb",$db);



$result = mysql_query("SELECT * FROM employees",$db);



if ($myrow = mysql_fetch_array($result)) {



  do {



    printf("<a href="%s?id=%s">%s %s</a><br>n", $PHP_SELF, $myrow["id"], $myrow["first"], $myrow["last"]);



  } while ($myrow = mysql_fetch_array($result));



} else {



  echo "Sorry, no records were found!";



}



?>







</body>







</html>

Everything’s about the same except the printf function, so let’s look at it in some detail.First notice that each quotation mark is preceeded by a backslash. The backslash tells PHP to display the character following it, rather than treat it as part of the code. Also note the use of the variable $PHP_SELF. This variable, which stores the script’s name and location, is passed along with every PHP page. It’s helpful here because we just want this file to call itself. Using $PHP_SELF, we can be sure that will happen, even if the file is moved to another directory – or even another machine.

As I just mentioned, these links will recall the page. On the second time through, however, some information will be added to the querystring.PHP does a nifty thing when it sees a name=value pair in the querystring. It automatically creates a variable with the name and value the querystring indicated. This feature allows us to test if it’s the first or second time through this page. All we have to do is ask PHP if the variable $id exists.Once I know the answer to that question, I can display a different set of information the second time through. Here’s how:

<html>



<body>



<?php







$db = mysql_connect("localhost", "root");



mysql_select_db("mydb",$db);



// display individual record



if ($id) {



   $result = mysql_query("SELECT * FROM employees WHERE id=$id",$db);



   $myrow = mysql_fetch_array($result);



   printf("First name:%sn<br>", $myrow["first"]);



   printf("Last name:%sn<br>", $myrow["last"]);



   printf("Address:%sn<br>", $myrow["address"]);



   printf("Position:%sn<br>", $myrow["position"]);



} else {



    // show employee list



   $result = mysql_query("SELECT * FROM employees",$db);



    if ($myrow = mysql_fetch_array($result)) {



      // display list if there are records to display



      do {



        printf("<a href="%s?id=%s">%s %s</a><br>n", $PHP_SELF, $myrow["id"], $myrow["first"], $myrow["last"]);



      } while ($myrow = mysql_fetch_array($result));



    } else {



      // no records to display



      echo "Sorry, no records were found!";



    }



}







?>





</body>



</html>

This code is getting complex now, so I’ve started to use comments to keep track of what’s going on. You can use // to make a single-line comment or /* and */ to start and end a large comment block.

And there we have it:your first truly useful PHP/MySQL script! Now let’s take a look at how to plug forms into it and send information back into the database.

Throw in Some Forms

We’ve managed to get data from a database without much difficulty. But what about sending data the other way? It’s not a problem with PHP.First let’s create a page with a simple form.

<html>



<body>







<form method="post" action="<?php echo $PHP_SELF?>">



First name:<input type="Text" name="first"><br>



Last name:<input type="Text" name="last"><br>



Address:<input type="Text" name="address"><br>



Position:<input type="Text" name="position"><br>



<input type="Submit" name="submit" value="Enter information">



</form>





</body>



</html>

Note the use of $PHP_SELF again. Like I said in Lesson 1, you can use PHP anywhere inside your HTML code. You’ll also notice that each form element matches the field name in the database. This is not compulsory; it’s just a good idea so you can get your head around your code later on.

Also notice that I’ve given the Submit button a name attribute. I’ve done this so I can test for the existence of a $submit variable. That way, when the page is called again, I’ll know whether someone used this form.I should mention that you don’t have to have a page that loops back on itself. You can span two, three, or more pages, if you like. This way everything stays compact.

OK, let’s add some code that will check for the form input. Just to prove that the form input does make it through, I’ll dump all the variables to the screen with $HTTP_POST_VARS. This is a useful debugging feature. If you ever need to see all the variables on a page, use $GLOBALS.

<html>



<body>



<?php







if ($submit) {



  // process form



  while (list($name, $value) = each($HTTP_POST_VARS)) {



    echo "$name = $value<br>n";



  }



} else{



  // display form



  ?>



  <form method="post" action="<?php echo $PHP_SELF?>">



  First name:<input type="Text" name="first"><br>



  Last name:<input type="Text" name="last"><br>



  Address:<input type="Text" name="address"><br>



  Position:<input type="Text" name="position"><br>



  <input type="Submit" name="submit" value="Enter information">



  </form>



  <?php







} // end if







?>







</body>







</html>

Now that this is looking good, let’s take the form information and post it to the database.

<html>



<body>







<?php







if ($submit) {



  // process form



  $db = mysql_connect("localhost", "root");



  mysql_select_db("mydb",$db);



  $sql = "INSERT INTO employees (first,last,address,position) VALUES ('$first','$last','$address','$position')";



  $result = mysql_query($sql);



  echo "Thank you! Information entered.n";



} else{







  // display form







  ?>







  <form method="post" action="<?php echo $PHP_SELF?>">



  First name:<input type="Text" name="first"><br>



  Last name:<input type="Text" name="last"><br>



  Address:<input type="Text" name="address"><br>



  Position:<input type="Text" name="position"><br>



  <input type="Submit" name="submit" value="Enter information">



  </form>







  <?php







} // end if







?>







</body>







</html>

You’ve now inserted data into the database. It’s still far from perfect. What if someone leaves a field blank or enters text when we want a numeric entry? What if there’s an error somewhere?Don’t worry. We’ll get to that.

Make the Forms Smarter

Throughout this tutorial, I’ve been loading the SQL statement into a variable ( $sql) before firing the query at the database with mysql_query(). This is useful for debugging. If something goes wrong, you can always echo the SQL to the screen to examine it for mistakes.

We already know how to get data into the database. Now let’s try modifying records that are already in the database. Editing data combines two elements we’ve already seen:displaying data on the screen and sending data back to the database via form input. However, editing is slightly different in that we have to show the appropriate data in the form.First, let’s recycle the code from Lesson 1 to display the employee names on our page. But this time through, we’re going to populate our form with employee information. It should look a little like this:

<html>



<body>



<?php







$db = mysql_connect("localhost", "root");



mysql_select_db("mydb",$db);



if ($id) {



  // query the DB



  $sql = "SELECT * FROM employees WHERE id=$id";



  $result = mysql_query($sql);



  $myrow = mysql_fetch_array($result);



  ?>







  <form method="post" action="<?php echo $PHP_SELF?>">



  <input type=hidden name="id" value="<?php echo $myrow["id"] ?>">



  First name:<input type="Text" name="first" value="<?php echo $myrow["first"] ?>"><br>



  Last name:<input type="Text" name="last" value="<?php echo $myrow["last"] ?>"><br>



  Address:<input type="Text" name="address" value="<?php echo $myrow["address"] ?>"><br>



  Position:<input type="Text" name="position" value="<?php echo $myrow["position"] ?>"><br>



  <input type="Submit" name="submit" value="Enter information">



  </form>







  <?php







} else {



  // display list of employees



  $result = mysql_query("SELECT * FROM employees",$db);



  while ($myrow = mysql_fetch_array($result)) {



    printf("<a href="%s?id=%s">%s %s</a><br>n", $PHP_SELF, $myrow["id"], $myrow["first"], $myrow["last"]);



  }



}







?>







</body>



</html>

We just echoed the field information into the value attribute of the each element, which was fairly easy. Let’s build on this a little more. We will add the ability to send the edited code back to the database. Again, we’re going to use the Submit button to test whether we need to process the form input. Also note the slightly different SQL statement we use.

<html>



<body>



<?php







$db = mysql_connect("localhost", "root");



mysql_select_db("mydb",$db);



if ($id) {



  if ($submit) {



    $sql = "UPDATE employees SET first='$first',last='$last',address='$address',position='$position' WHERE id=$id";



    $result = mysql_query($sql);



    echo "Thank you! Information updated.n";



  } else {



    // query the DB



    $sql = "SELECT * FROM employees WHERE id=$id";



    $result = mysql_query($sql);



    $myrow = mysql_fetch_array($result);



    ?>







    <form method="post" action="<?php echo $PHP_SELF?>">



    <input type=hidden name="id" value="<?php echo $myrow["id"] ?>">



    First name:<input type="Text" name="first" value="<?php echo $myrow["first"] ?>"><br>



    Last name:<input type="Text" name="last" value="<?php echo $myrow["last"] ?>"><br>



    Address:<input type="Text" name="address" value="<?php echo $myrow["address"] ?>"><br>



    Position:<input type="Text" name="position" value="<?php echo $myrow["position"] ?>"><br>



    <input type="Submit" name="submit" value="Enter information">



    </form>



	<?php



	}



} else {







  // display list of employees



  $result = mysql_query("SELECT * FROM employees",$db);



  while ($myrow = mysql_fetch_array($result)) {



    printf("<a href="%s?id=%s">%s %s</a><br>n", $PHP_SELF, $myrow["id"], $myrow["first"], $myrow["last"]);



  }



}







?>







</body>





</html>

And that’s that. We’ve managed to combine most of the features we’ve seen into one script. You can also see how we’ve used an if() statement inside another if() statement to check for multiple conditions.It’s time to put it all together and make one killer script.

All Together Now

We'll finish up this lesson by putting everything into a single page that can add, edit, and remove entries from the database. It's an extension of what we've covered so far and makes for a good review. Let's take a look.

 <html>



 <body>







 <?php







 $db = mysql_connect("localhost", "root");



 mysql_select_db("mydb",$db);







 if ($submit) {



   // here if no ID then adding else we're editing



   if ($id) {



     $sql = "UPDATE employees SET first='$first',last='$last',address='$address',position='$position' WHERE id=$id";



   } else {



     $sql = "INSERT INTO employees (first,last,address,position) VALUES ('$first','$last','$address','$position')";



   }



   // run SQL against the DB



   $result = mysql_query($sql);



   echo "Record updated/edited!<p>";



 } elseif ($delete) {



 	// delete a record



     $sql = "DELETE FROM employees WHERE id=$id";



     $result = mysql_query($sql);



     echo "$sql Record deleted!<p>";



 } else {



   // this part happens if we don't press submit



   if (!$id) {



     // print the list if there is not editing



     $result = mysql_query("SELECT * FROM employees",$db);



     while ($myrow = mysql_fetch_array($result)) {



       printf("<a href="%s?id=%s">%s %s</a> n", $PHP_SELF, $myrow["id"], $myrow["first"], $myrow["last"]);



 	  printf("<a href="%s?id=%s&delete=yes">(DELETE)</a><br>", $PHP_SELF, $myrow["id"]);



     }



   }







   ?>





   <P>



   <a href="<?php echo $PHP_SELF?>">ADD A RECORD</a>



   <P>



   <form method="post" action="<?php echo $PHP_SELF?>">





   <?php







   if ($id) {



     // editing so select a record



     $sql = "SELECT * FROM employees WHERE id=$id";



     $result = mysql_query($sql);



     $myrow = mysql_fetch_array($result);



     $id = $myrow["id"];



     $first = $myrow["first"];



     $last = $myrow["last"];



     $address = $myrow["address"];



     $position = $myrow["position"];



     // print the id for editing







     ?>



     <input type=hidden name="id" value="<?php echo $id ?>">



     <?php



   }







   ?>



   First name:<input type="Text" name="first" value="<?php echo $first ?>"><br>





   Last name:<input type="Text" name="last" value="<?php echo $last ?>"><br>



   Address:<input type="Text" name="address" value="<?php echo $address ?>"><br>



   Position:<input type="Text" name="position" value="<?php echo $position ?>"><br>





   <input type="Submit" name="submit" value="Enter information">



   </form>







 <?php







 }







 ?>







 </body>



 </html>

This looks complex, but it really isn’t. The script is broken up into three parts. The first if() statement checks to see whether the Submit button has been pressed, and if it has, it checks to see whether the variable $id exists. If doesn’t, then we’re adding a record. Otherwise, we’re editing a record.Next we check to see whether the variable $delete exists. If it does, we delete a record. Note that with the first if() statement we checked for a variable that came through as a POST, and in this one, the variable would be part of a GET.

Finally, we take the default action that displays the list of employees and the form. Again we check for the existence of the $id variable. If it exists, we query the database to display the relevant record. Otherwise, we display a blank form.We’ve now put all we’ve learned into one script. We used while() loops and if() statements, and we ran the gamut of the basic SQL statements – SELECT, INSERT, UPDATE, and DELETE. Lastly, we’ve looked at how we can pass information from one page to another using URLs and form input.

In lesson 3 we’ll look at how to make the page more intelligent.

• PHP and MySQL Tutorial
• PHP and MySQL Tutorial – Lesson 1
• PHP and MySQL Tutorial – Lesson 2
• PHP and MySQL Tutorial – Lesson 3

Welcome to the third and final lesson for this tutorial. If you’ve gone through Lesson 1 and Lesson 2, you already know the essentials for installing and writing useful scripts with MySQL and PHP. We’re going to look at some useful PHP functions that should make your life a lot easier. First, let’s look at include files.

We all know the basics of includes, right? Contents of an external file are referenced and imported into the main file. It’s pretty easy:You call a file and it’s included. When we do this in PHP there are two functions we need to talk about:include() and require(). The difference between these two functions is subtle but important, so let’s take a closer look. The require() function works in a XSSI-like way; files are included as part of the original document as soon as that file is parsed, regardless of its location in the script. So if you decide to place a require() function inside a conditional loop, the external file will be included even if that part of the conditional loop is false.

A Place for Everything

The include() function imports the referenced file each time it is encountered. If it’s not encountered, PHP won’t bother with it. This means that you can use include in loops and conditional statements, and they’ll work exactly as planned.

Finally, if you use require() and the file you’re including does not exist, your script will halt and produce an error. If you use include(), your script will generate a warning, but carry on. You can test this yourself by trying the following script. Run the script, then replace include() with require() and compare the results.

<html>



<body>

<?php

include("emptyfile.inc");

echo "Hello World";

?>

</body>

</html>

I like to use the suffix .inc with my include files so I can separate them from normal PHP scripts. If you do this, make sure that you set your Web server configuration file to parse .inc files as PHP files. Otherwise, hackers might be able to guess the name of your include files and display them through the browser as text files. This could be bad if you’ve got sensitive information – such as database passwords – contained in the includes.

So what are you going to do with include files? Simple! Place information common to all pages inside them. Things like HTML headers, footers, database connection code, and user-defined functions are all good candidates. Paste this text into a file called header.inc.

<?php

$db = mysql_connect("localhost", "root");

mysql_select_db("mydb",$db);

?>

<html>

<head>

<title>

<?php echo $title ?>

</title>

</head>

<body>

<center><h2><?php echo $title ?></h2></center>

Then create another file called footer.txt that contains some appropriate closing text and tags.

Now let’s create a third file containing the actual PHP script. Try the following code, making sure that your MySQL server is running.

<?php

$title = "Hello World";

include("header.inc");

$result = mysql_query("SELECT * FROM employees",$db);

echo "<table border=1>n";

echo "<tr><td>Name</td><td>Position</tr>n";

while ($myrow = mysql_fetch_row($result)) {

  printf("<tr><td>%s %s</td><td>%s</tr>n", $myrow[1], $myrow[2], $myrow[3]);

}

echo "</table>n";

include("footer.inc");

?>

See what happens? The include files are tossed into the main file and then the whole thing is executed by PHP. Notice how the variable $title was defined before header.inc is referenced. Its value is made available to the code in header.inc; hence, the title of the page is changed. You can now use header.inc across all your PHP pages, and all you’ll have to do is change the value of $title from page to page.

Using a combination of includes, HTML, conditional statements, and loops, you can create complex variations from page to page with an absolute minimum of code. Includes become especially useful when used with functions, as we’ll see down the road.On to the exciting world of data validation.

Simple Validation

Imagine for a moment that we’ve got our database nicely laid out and we’re now requesting information from users that will be inserted into the database. Further, let’s imagine that you have a field in your database waiting for some numeric input, such as a price. Finally, imagine your application falling over in a screaming heap because some smart aleck put text in that field. MySQL doesn’t want to see text in that portion of your SQL statement – and it complains bitterly.

What to do? Time to validate.

Validation simply means that we’ll examine a piece of data, usually from an HTML form, and check to make sure that it fits a certain model. This can range from ensuring that a element is not blank to validating that an element meets certain criteria (for example, that a numeric value is stipulated or that an email address contains an @ for an email address).

Validation can be done on the server side or on the client side. PHP is used for server-side validation, while JavaScript or another client-based scripting language can provide client-side validation. This article is about PHP, so we’re going to concentrate on the server end of things.

Let’s ignore our database for the moment and concentrate on PHP validation. If you wish, you can add additional fields to our employee database quite simply by using the MySQL ALTER statement – that is, if you want to commit to the values that we’ll validate.

There are several useful PHP functions we can use to validate our data, and they range from simple to highly complex. A simple function we could use might be strlen(), which tells us the length of the variable.

A more complex function would be ereg(), which uses full regular expression handling for complex queries. I won’t delve into the complexities of regex here, as entire books have been written on the subject, but I will provide some examples on the next page.

Let’s start with a simple example. We’ll check to see whether a variable does or does not exist.

 <html>

 <body>

 <?php

 if ($submit) {

      if (!$first || !$last) {

 	$error = "Sorry! You didn't fill in all the fields!";

 	} else {

 		// process form

 		echo "Thank You!";
 	}
 }

 if (!$submit || $error) {

      echo $error;

      ?>

      <P>

      <form method="post" action="<?php echo $PHP_SELF ?>">

      FIELD 1:<input type="text" name="first" value="<?php echo $first ?>">

      <br>

      FIELD 2:<input type="text" name="last" value="<?php echo $last ?>">

      <br>

      <input type="Submit" name="submit" value="Enter Information">

      </form>

      <?php

 } // end if

 ?>

 </body>

 </html>

The keys to this script are the nested conditional statements. The first checks to see whether the Submit button has been pressed. If it has, it goes on to check that both the variables $first and $last exist. The || symbol means “or” and the ! symbol means “not.” We could also rewrite the statement to say, “If $first does not exist or $last does not exist, then set $error to the following.”

Next, let’s extend things a little by checking to see whether a string is a certain length. This would be ideal for passwords, since you don’t want some lazy user entering a password of only one or two letters. You’d rather it be, say, six or more characters.

The function for this is, as you already know, strlen(). It simply returns a number equal to the number of characters in the variable being tested. Here, I modified the script above to check the length of $first and $last.

 <html>

 <body>

 <?php

 if ($submit) {

      if (strlen($first) < 6 || strlen($last) < 6) {

 	$error = "Sorry! You didn't fill in all the fields!";

 	} else {

 		// process form

 		echo "Thank You!";

 	}

 }

 if (!$submit || $error) {

      echo $error;

      ?>

      <P>

      <form method="post" action="<?php echo $PHP_SELF ?>">

      FIELD 1:<input type="text" name="first" value="<?php echo $first ?>">

      <br>

      FIELD 2:<input type="text" name="last" value="<?php echo $last ?>">

      <br>

      <input type="Submit" name="submit" value="Enter Information">

      </form>

      <?php

 } // end if

 ?>

 </body>

 </html>

Run this script and try entering six or fewer letters to see what happens. It’s simple yet quite effective.

Not-So-Simple Validation

Let’s talk a bit about using regular expressions with the ereg() and eregi() functions. As I said earlier, these can be either quite complex or very simple, depending on what you need.

Using regular expressions, you can examine a string and intelligently search for patterns and variations to see whether they match the criteria you set. The most common of these involves checking whether an email address is valid (although, of course, there’s no fail-safe way of doing this).

Rather than delve into the mysteries of regular expressions, I’ll provide some examples. You can use the same form we created on the previous page – just paste in the lines below to see how they work.

First, let’s make sure that text only has been entered into a form element. This regular expression tests true if the user has entered one or more lowercase characters, from a to z. No numbers are allowed:

 if (!ereg("[a-Z]", $first) || !ereg("[a-Z]", $last)) { 

Now, let’s extend this expression to check whether the string is four to six characters in length. Using alpha: is an easy way to check for valid alphabetic characters. The numbers in the braces check for the number of occurrences. And note that the ^ and $ indicate the beginning and end of the string.

 if (!ereg("^[[:alpha:]]{4,6}$", $first) || !ereg("^[[:alpha:]]{4,6}$", $last)) { 

Finally, let’s build a regular expression that will check an email address’ validity. There’s been plenty of discussion about the effectiveness of checking for email addresses in this way. Nothing’s completely foolproof, but what I have below works pretty well.

I took this gem from the PHP mailing list. It’s a great resource – use it. And yes, this is as scary as it looks.

	if (!ereg('^[-!#$%&'*+./0-9=?A-Z^_`a-z{|}~]+'.

'@'.

'[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+.'.

'[-!#$%&'*+./0-9=?A-Z^_`a-z{|}~]+$', $last)) {

Don’t spend too much time looking at this. Just move on to the next bit.

Functions

Enjoy that last regex expression? Fun, wasn’t it? Wouldn’t it be even more fun to enter that chunk on a dozen different pages that need to process email addresses?! Think about the joy of finding a typo in that mess – and doing it a dozen times no less. But of course, there’s a better way.

Remember when we talked about include files earlier in this lesson? They’ll allow us to create a piece of code like the email checker and include it multiple times across several pages. This way, when we want to change the code, we need edit only one file, not many.

But if we want to get this done, we’ll have to use functions.

We’ve already used functions plenty of times. Every time we query the database or check the length of a string we’re using functions. These functions are built into PHP. If you’re a keen coder, you can extend PHP with your own customized functions. But that’s a bit advanced for this tutorial. Instead we’ll create functions that will reside within our PHP script.

A function is simply a block of code that we pass one or more values to. The function then processes the information and returns a value. The function can be as simple or complex as we like, but as long as we can pass a value in and get one out, we don’t really care how complex it is. That’s the beauty of functions.

Functions in PHP behave similarly to functions in C. When we define the functions, we must specify what values the function can expect to receive. It’s tricky to get a handle on at first, but it prevents weird things from happening down the road. This is done because the variables inside a function are known as private variables. That is, they exist only inside the function. You may, for instance, have a variable in your script called $myname. If you created a function and expected to use the same $myname variable (with the same value), it wouldn’t work. Alternatively, you could have the variable $myname in your script and also create another variable called $myname in your function, and the two would co-exist quite happily with separate values. I do not recommend doing this, however! When you come back and edit it six months later, you’ll be breaking things left and right. There are exceptions to this rule as with all things, but that’s outside the scope of this article.

So let’s create a function. We’ll start simply. We need to give the function a name and tell it what variables to expect. We also need to define the function before we call it.

 <html>
 <body>

 <?php

 function  addnum($first, $second) {

 	$newnum = $first + $second;

	return $newnum;

 }

 echo addnum(4,5);

 ?>

 </body>

 </html>

That’s it! First, we created our function. Notice how we defined two new variables, called $first and $second. When we call the function, each variable is assigned a value based on the order in which it appears in the list – 4 goes to $first, 5 to $second. Then we simply added the two numbers together and returned the result. “Return” here simply means to send the result back. At the end of the script we print the number 9.

Let’s create something that’s more useful to our database application. How about something that gracefully handles errors? Try this:

 <html>
 <body>

 <?php

 function  do_error($error) {

 	echo  "Hmm, looks like there was a problem here...<br>";

 	echo "The reported error was $error.n<br>";

 	echo "Best you get hold of the site admin and let her know.";

 	die;
 }

 if (!$db = @mysql_connect("localhost","user", "password")) {

 	$db_error = "Could not connect to MySQL Server";

 	do_error($db_error);

 }

 ?>

 </body>
 </html>

Before running this, try shutting down MySQL or using a bogus username or password. You’ll get a nice, useful error message. Observant readers will notice the @ symbol in front of mysql_connect(). This suppresses error messages so that you get the information only from the function. You’ll also see we were able to pass a variable into the function, which was defined elsewhere.

Remember that I said functions use their own private variables? That was a little white lie. In fact, you can make variables outside of a function accessible to the function. You might create a function to query a database and display a set of results over several pages. You don’t want to have to pass the database connection identifier into the function every time. So in this situation, you can make connection code available as a global variable. For example:

 <html>

 <body>

 <?php

 function  db_query($sql) {

 	global $db;

 	$result = mysql_query($sql,$db);

 	return $result;

 }

 $sql = "SELECT * FROM mytable";

 $result = db_query($sql);

 ?>

 </body>

 </html>
 

This is a basic function, but the point is that you don’t need to send $db through when you call the function – you can make it available using the word global. You can define other variables as global in this statement, just separate the variable names by a comma.

Finally, you can look like a real pro by using optional function variables. Here, the key is to define the variable to some default in the function, then when you call the function without specifying a value for the variable, the default will be adopted. But if you do specify a value, it will take precedence.

Confused? For example, when you connect to a database, you nearly always connect to the same server and you’ll likely use the same username and password. But sometimes you’ll need to connect to a different database. Let’s take a look.

 <html>
 <body>
 <?php

 function  db_connect($host = "localhost", $user="username", $pass="graeme") {

 	$db = mysql_connect($host, $username, $password);

 	return $db;

 }

 $old_db = db_connect();

 $new_host = "site.com";

 $new_db = db_connect($new_host);

 ?>

 </body>

 </html>
 

Isn’t that cool? The variables used inside the function were defined when the function was defined. The first time the function is called, the defaults are used. The second time, we connect to a new host, but with the same username and password. Great stuff!

Think about where you could use other functions in your code. You could use them for data checking, performing routine tasks, and so on. I use them a lot when processing text for display on a Web page. I can check, parse, and modify the text to add new lines and escape HTML characters in one fell swoop.

Now all that’s left to do is to impart some words of wisdom.

Closing Advice

When it comes to databasing, there’s a lot to learn. If you haven’t done it already, find a good book about database design and learn to put together a solid database – on any platform. It’s an invaluable skill and it will save you plenty of time and headache in the long run. Also, learn about MySQL. It’s a complex but interesting database with a wealth of useful documentation. Learn about table structure, data types, and SQL. You can actually achieve some pretty impressive stuff if you know enough SQL.

Finally, there’s PHP. The PHP Web site has nearly everything you need, from a comprehensive manual to mailing-list archives to code repositories. An excellent way to learn about PHP is to study the examples used in the manual and to check out the code archives. Many of the posted scripts consist of functions or classes that you can use for free in your own scripts without having to reinvent the wheel. Additionally, the mailing list is an excellent spot to check out if you get stuck. The developers themselves read the list and there are plenty of knowledgeable people there who can help you along the way.

Good luck and good coding!

• PHP and MySQL Tutorial
• PHP and MySQL Tutorial – Lesson 1
• PHP and MySQL Tutorial – Lesson 2
• PHP and MySQL Tutorial – Lesson 3

In my last article, Building With Ajax and Rails I made a faintly disparaging joke about some new web frameworks that have been created in fond imitation of Rails. I got a lot of feedback about that joke. I’m not allowed to comment here about the pending lawsuits, but I would ask that the drive-by eggings of my house and threats to my family please cease. (They’ve been relocated to a secret Webmonkey farm anyway.)

Today we’re going to take a look at a couple of those frameworks for PHP:Trax and Cake. Both attempt to bring the quick, easy, helpful tools and easily understood, easily maintained structure of Rails to PHP — a boon to web developers who know PHP and perhaps have some keeper code in that language, but can’t resist the Rails buzz. Both Trax and Cake use the same model-view-controller pattern and Active Record ways of addressing data that Rails does. Makes one curious, no? I don’t have time to get deeply into them today, but both stress “rapid development,” so let’s see if I, your average not-too-bright web developer, can get a little app off the ground before the end of this article.

Cutting into Cake

This is 100 percent true:At lunch yesterday, my fortune cookie said “A nice cake is waiting for you.” So, I am going to start with Cake first and try Trax later.

I go to the Cake site and download the latest stable release (discouragingly called 1.1.19.6305) onto my Debian web server running Apache and PHP 5. Unzipping the tarchive, I immediately see some names that look familiar from Rails:app, config and something called dispatcher.php. The app directory looks even friendlier. It contains views, controllers, model – just like Rails!

There’s also a webroot directory, which I assume is going to be the root of my application. Indeed, look at that! If I browse to http://my.web.server/trax_and_cake_playground/cake/app/webroot, I see a friendly boilerplate intro page. Later, if I decide I want to use Cake full time, I’ll add a line to my Apache configuration to set that directory as the whole server’s root directory. At the moment, the page is extolling Cake’s coolness and warning me, “Your database configuration file is not present.”

Correct, it’s not. I find a sample database configuration in app/config/database.php.default. I’ll copy that sample to an actual working file, database.php, in the same directory. The file includes an array of settings, which I change to suit my own environment:

var $default = array('driver'   => 'mysql',



                  'connect'  => 'mysql_pconnect',



                  'host'     => 'localhost',



                  'login'    => 'paul',



                  'password' => 'passw0rd',



                  'database' => 'bookmarker' );

Now, when I reload the intro page, it tells me, “Your database configuration file is present. Cake is able to connect to the database.” Yay!

Now, I’ve told it I have a MySQL database called “bookmarker,” but that’s not true yet. I still have to create it. I’m eager to get rolling, so I’ll just recycle the code from Webmonkey’s Ruby on Rails for Beginners article in which I built a bookmarking app. This time I also want to populate the table with a little starter data, to give us something to work with. So I type:

 $mysql



 mysql> CREATE DATABASE bookmarker;



 mysql> USE bookmarker;



 mysql> CREATE TABLE bookmarks (



    ->  id SMALLINT (5) NOT NULL auto_increment,



    ->  url VARCHAR (255),



    ->  name VARCHAR (100),



    ->  description VARCHAR (255),



    ->  PRIMARY KEY (id)



    -> );



 mysql> INSERT INTO bookmarks (url, name, description) VALUES



 ('http://webmonkey.com/', 'Webmonkey', 'Not the only monkey that makes



 websites, but the best!');



 mysql> INSERT INTO bookmarks (url, name, description) VALUES



 ('http://ubuntu.com/', 'Ubuntu', 'Linux for human beings (no monkeys



 please!)');



 mysql> exit;

At this point in developing a Rails app, I’d run the built-in scaffold-generating tool. Here in Cakeland, I see a file called bake.php in cake/scripts, and instantly I pick up on the metaphor – bake a cake, get it? Turns out that’s a false start, as bake.php doesn’t seem to work in the pre-beta. It’s giving me all sorts of fatal errors and files not found. I’m going to have to create my model, view and controller by hand-editing code.

The app/models directory contains an empty file called put_models_here. So, I do just that, creating a file in that directory called bookmark.php:

 <?php



 class Bookmark extends AppModel



 {



     var $name = 'Bookmarks';



    function display()



     {



         $this->set('data',$this->Bookmark->findAll());



     }



 }



 ?>

That puts the data from the table in $data, using the built-in set method. You might want to read along in the Cake API documentation – I certainly am!

Then I create a controller, app/controllers/bookmarks_controller.php:

 <?php



 class BookmarksController extends AppController



 {



     var $name = 'Bookmarks';



 }



 ?>

I will also need to create a view. In the app/views directory, I create a subdirectory called bookmarks and a file called index.thtml inside of the subdirectory. The “t” in the file extension is for template, I assume. Note that I have had to scratch around in some slightly opaque documentation to glean all this – not as polished as Rails, not yet at least! In index.thtml I just put together a little foreach loop to display my content:

<?php



 echo "<p><table>";



 foreach ($data as $bookmark):



      echo "<tr><td>";



      echo $html->link($bookmark['Bookmark']['name'],



 $bookmark['Bookmark']['url']);



      echo "</td><td><b>";



      echo $bookmark['Bookmark']['description'];



      echo "</b></td></tr>";



 endforeach;



 echo "</table><p>";



 ?>

Finally, I need to add routing in order to tell Cake where my little app is and what to do with it. In app/config/routes.php I add a line:

 $Route->connect ('/bookmarks/*', array('controller'=>'bookmarks',



 'action'=>'display'));

Note that the action, “display”, corresponds to the method I defined in my controller.

Now all the pieces are in place at last. I browse to http://my.web.server/trax_and_cake_playground/cake/index.php/ bookmarks (I can clean up that ugly URL later) and lo! The boilerplate page is now displaying the preliminary bookmarks I put in my table! I am up and running. In Rails, at this point, I would have some nice auto-generated methods to add and delete bookmarks. Hopefully Cake’s auto-bake feature will come together soon.

Next, let’s take a look at Trax.

Makin’ Trax

Quick now, we know the drill. Go to the Trax site, download the archive, untar it. Like all of these prima-donna frameworks, Trax wants to be the top level of my web hierarchy, or rather it wants its public directory to be, and its trax directory to be parallel at the same level, out of sight of prying eyes. If my web server were publicly accessible, I’d put it up there, or find a way around that limitation. For now I’ll just unzip it in my playground (so to speak). Whoo!

Already now, if I go to http://my.web.server/trax_and_cake_playground/trax/public/, I have a page telling me “Congratulations, you’ve put PHP on Trax!” I feel good.

Trax does have a working auto-generate function, which is very nice, because I am getting tired of hand-editing all these files. If I wanted to do that, I’d be writing Perl or something. Still, there are a few more steps. I need to install the PEAR modules that Trax requires, which I do on the command-line:

 pear install Mail_Mime

I’ll use the same database and table I created back at the beginning, so long ago. I need to configure trax/config/database.ini to tell the application where they are:

    phptype = mysql



    database = bookmarker



    hostspec = localhost



    username = paul



    password = passw0rd



    persistent = 1

And then I need to edit public/.htaccess to tell the application where in my file system its own configuration is. The start of that file reads:

 # php include path for Trax ( Pear & Trax config dir )



 php_value include_path



 .:/usr/local/lib/php:/home/<username>/trax/config

I change it to suit my Debian setup:

 # php include path for Trax ( Pear & Trax config dir )



 php_value include_path .:/usr/share/php:/var/www/html/trax/trax/config

Now I am ready to — make Trax? Lay down Trax? There doesn’t seem to be a catchy verb for auto-generating models and controllers and views here. I, um, look both ways and prepare to cross the Trax.

The script that does the work is trax/script/generate.php. First, I need to edit the first line of that file to point to where my PHP executable actually is. Not /usr/local/bin/php, as the default has it. Mine is at /usr/bin/php. Also, the script seems to be happiest if I add my path information there as well, so toward the beginning of the file I enter the following:

 ini_set("include_path", ".:/usr/share/php:/var/www/html/trax/trax/config"); 

While I’m at it, I’ll add the same line to public/dispatch.php.

Then I need to make generate.php executable with a deft chmod a+x.

Now I’m ready to run the generate script, which I do from the command line. If your server doesn’t like PHP scripts to be run from the command line, you’ll have to open the script in a browser. I type this:

 ./trax/script/generate.php model Bookmark 

and Trax replies:

 created /var/www/html/trax/trax/app/models/bookmark.php 

Then I type:

 ./trax/script/generate.php controller bookmark display add 

and Trax replies:

created /var/www/html/trax/trax/app/controllers/bookmark_controller.php



 created /var/www/html/trax/trax/app/helpers/bookmark_helper.php



 created /var/www/html/trax/trax/app/views/bookmark/display.phtml



 created /var/www/html/trax/trax/app/views/bookmark/add.phtml

“Display” and “add” are the initial views I want. Finally (I hope), I just need to add routing, so I can view my views in a browser. I add the following to trax/config/routes.php:

 $router->connect( "", array(":controller" => "bookmark") ); 

and voila! I can see a page! True, it’s blank, which means that I need to flesh out my actions and views. But it is a page! Let me just put in a couple of basics.

In trax/app/controllers/bookmark_controller.php, there’s an empty definition of the view() method. I’ll put this in:

 function view() {



        $bookmark = new Bookmark();



        $this->bookmarks = $bookmark->find_all();



    }

and in app/views/bookmark/display.phtml I put a PHP table similar to the one I used for Cake, to loop through the bookmarks table and display each one.

Whew. Two starter semi-apps built in as many hours. Not too bad.

Hardly the End of the Story

Would I do it again? Are either of the frameworks are 100 percent ready for prime time? Documentation is getting better every day, but neither framework has anything like the whopping user community of Rails.

I was able to iron out my own snags — several had to do with permissions, Apache directory overrides, and stuff like that – but if I couldn’t, it would be nice to have more resources to turn to. Conversely, PHP has a considerably larger support community on the Web than Ruby does, although that tide may slowly be turning.

Trax and Cake aren’t the end of the PHP dev framework story:there’s Symfony; Zend has a framework and a quick trawl of the web turns up things like PHP2Go, Qcodo and doubtless many more.

Rails is a pleasure to use, while Trax and Cake combine pleasure with a bit of effort. If you’re a PHP wiz, though, the fact that they’re based in a language you know should more than outweigh any difficulties brought on by the frameworks’ immaturity. It’s easier to debug a stuck app than to learn a whole new language, even one as perspicuous and enjoyable as Ruby.

So tune in next time when we cover Brails, the new web programming framework for the visually impaired! That’s a joke. Don’t sue.

Helpful Links

• Visit CakePHP.org
• Visit The Bakery
• Visit the CakePHP forum at Nabble

• Visit the Trax forum