Today, we’ve published the beginning of the series: the Introduction and directly from the book, Chapter 1: Installation. Over the weekend you can read chapter 1 and make sure your newly installed software is working properly, in readiness for next week’s chapters. At the end of the week you’ll have 4 complete chapters from the book and one bonus article, comprising another book excerpt.

Here’s what you’ll be receiving:

Chapter 2: Introducing MySQL

An introduction to databases in general, and the MySQL relational database management system in particular. If you’ve never worked with a relational database before, you’ll find this enlightening, whetting your appetite for what’s to come! In the process, you’ll build up a simple database to be used in later chapters.

Chapter 3: Introducing PHP

Here’s where the fun really starts. In this chapter, Kevin will introduce you to the PHP scripting language, which you can use to build dynamic web pages that present up-to-the-moment information to your visitors.

Chapter 4: Publishing MySQL Data on the Web

In this chapter you’ll bring together PHP and MySQL to create some of your first database driven web pages. You’ll explore the basic techniques of using PHP to retrieve information from a database and display it on the Web in real time. Kevin will also show you how to use PHP to create web-based forms for adding new entries to, and modifying existing information in, a MySQL database on the fly.

Bonus: How to Handle File Uploads with PHP
In this bonus excerpt from Chapter 12, you’ll learn how to accept file uploads from your web site visitors securely and store them.

Build Your Own Database Driven Web Site Using PHP & MySQL, 4th Edition is one of the most popular PHP books for beginners, and SitePoint’s first ever book. This shiny new 4th edition has been completely updated using only best-practice PHP. It’s essential reading for all budding PHP & MySQL developers. For more information, see the book page.

If you prefer to read the Adobe Acrobat PDF version of these first four chapters, you can download the first four chapters FREE.

Build Your Own Database Driven Web Site Using PHP & MySQL (4th Edition) — by Kevin Yank

One of the most popular PHP books for beginners, this shiny new 4th edition has been completely updated using only best-practice PHP.

In this book you’ll learn how to:

• install PHP 5 and MySQL 5 on Windows, Linux, or Mac OS X
• gain a thorough understanding of PHP syntax
• master database design principles and SQL
• build a working content management system
• add, edit, and delete web content without using HTML
• create an ecommerce shopping cart
• utilize sessions and cookies to track site visitors
• craft SEO-friendly and memorable URLs

And a whole lot more …

At around 480 pages, this book is an easy read. As you move through the book you’ll quickly notice that it’s written in a clear tutorial format that’s easy to understand, and illustrated with plenty of screenshots and diagrams, providing quick visual cues. If you hate wading through dry, academic-style “how to” texts, this book will be a breath of fresh air to you.

If you’ve never built a database driven web site and you’re looking to go beyond the limitations of a static site, this book will start you off in no time.

And if you have built database driven web sites before, the extensive PHP/MySQL reference guides included will ensure this book remains an extremely handy desk reference.

Check out the free sample chapters or order a copy today.

SitePoint is looking for two experienced PHP developers (one with a sysadmin twist) to join the team here at SitePoint HQ in Melbourne, Australia. Help us find the right person for either of these positions, and we’ll buy you a shiny, new iPhone 3GS!

Know someone with “mad PHP skillz” who either lives in Melbourne or would move here for the opportunity to work on one of the Web’s major destination sites for web developers and designers? Drop me an email with the details at kevin(at)sitepoint.com.

Of course, if you would just like to apply for the position yourself, the complete position descriptions are in our jobs section.

The project includes an article on “PHP performance tips”, which is bordering on being ridiculous. There are of course lots of blog posts with similar nonsense around the web, but since this is being endorsed by Google, it’s fair to assume that people might take it at face value. That’s unfortunate, as almost none of it is true. The PHP Team responded back with this message, wherein they refute the unfounded nonsense.

What’s more troubling however, is the whole approach to performance optimisation as a matter of “knowing the secret handshake”. Optimisation is far more complex than that, and spending time on these “optimisation tricks” are rarely worthwhile and might often lead to unmaintainable code, if applied too early. It’s a fine line, because there are of course certain things that you shouldn’t do (such as hit the database within a tight loop, if you can send one query instead), but there are likewise lots of things that are a complete and utter waste of every body’s time. It’s a pity that this article failed to keep those two issues separate.

Performance optimisation is not magic. The real way to deal with it, is to measure and analyse. It is almost impossible — even for a highly skilled programmer — to anticipate exactly where there might be bottlenecks in a program. Using a profiler gives you real numbers to relate to, rather than wild guesses and superstition.

For PHP scripts, there is the freely available Xdebug extension, which provides detailed information on both memory usage and execution time on a per-function basis. It’s easy to install and with the simple WebGrind as a front-end, you’ll be up and running in no time.

Agavi: This PHP 5-based framework started off as a fork of the popular Mojavi project. While it can be used as a web site construction kit, its primary focus is on building fully-fledged applications.

Akelos: Akelos is a PHP port of a Ruby on Rails framework for building web applications. It avoids complex configurations, making it ideal for use on simpler web servers. There’s a healthy community around this one!

CakePHP: The very well-known CakePHP is easy for coders of all skill levels to use. It’s based on the same principles that guide Ruby on Rails, and its heavy focus on rapid deployment methods make it a great choice for developers who are squeezed for time (see SitePoint’s beginner’s CakePHP tutorial to get started).

CodeIgniter: EllisLab’s CodeIgniter has won wide praise for its small footprint and speed, and has become a favorite amongst many developers. There’s extensive documentation and a large community of users to help you out.

eZ Components: OK, so we’re stretching the definition of framework here. eZ Components, as the name suggests, is a library of individual components for common tasks. If you’re familiar with the ezPublish CMS, you might have seen some of these components before!

Fuse: Fuse is based on Ruby on Rails and CakePHP, but has had many features added by the development team to make the most stable platform they could. There are frequent updates—development on version 2.0 is underway!

Horde: This mainstay of the PHP framework world grew from the Horde webmail and groupware suite. If you’re a developer who speaks a language other than English, you may be interested in the fact that the framework is designed specifically to be localization-friendly.

Kohana: Kohana, originally based on CodeIgniter, puts its focus on being small, fast, and secure.

PHP on TRAX: A PHP framework based on Ruby on Rails (Get that name? Nudge nudge!) that is focused on building database-backed web applications based on the MVC structure. You’ll find a healthy developer community, demos, and even screencasts.

PHPOpenBiz: This PHP framework claims to have business development in mind, though we’re not sure how it is that other frameworks aren’t suitable for that purpose.

Qcubed: Qcubed is a fork of the Qcodo framework which had remained dormant for some time. It’s back, and its focus is on rapid prototyping. You’ll find fun tutorials on the site, and an enthusiastic new set of developers.

Seagull: This well-established PHP framework is easy to pick up for developers of any skill level. If you’re a beginner, you’ll find many pre-built apps to examine and extend, and there’s something for experts too—cash bounties are offered for improvements to the code.

Symfony: The ever-popular Symfony is directed more at enterprise application development, and it may have some trouble with shared hosting solutions as they lack a PHP accelerator. This is definitely more of an advanced developer framework than some of the others out there.

WACT: Short for Web Application Component Toolkit, WACT emphasizes the need for frequent code refactoring, unit testing, and good security.

Zend: Zend is focused on Web 2.0 style applications. It’s simple to use APIs from sites such as Google, Flickr, Amazon and so on (check out the SitePoint Zend tutorial for more on this). With a massive user base, you’re sure to find plenty of support and advice around the Web.

ZooP: A mature PHP framework for beginners and advanced users alike, ZooP focuses on being lightweight and easy to learn. Features include easy use of PEAR modules, the prototype Ajax framework and stacks of documentation.

Of course there are many more frameworks out there—users of our PHP Application Design Forum drop by every day with discussions of what they’re working on. What’s your favorite PHP framework and why?

Bucket doesn’t do much, but that is actually the intention. It means that it is feature-complete and probably bug free. And unlike Twittee, it is actually useful as-is.

Bucket is mostly a wrap-up of the code I described a bout a year back in Dealing with Dependencies. It adds a few additional features out-of-the-box. Notably:

Default factory uses reflection/typehints to determine dependencies. So you can go:

class Foo {
}
class Bar {
  function __construct(Foo $foo) {}
}
$container = new bucket_Container();
$container->get('Bar');

And with interfaces:

interface Zap {
}
class Foo implements Zap {
}
class Bar {
  function __construct(Zap $zap) {}
}
$container = new bucket_Container();
$container->registerImplementation('Zap', 'Foo');
$container->get('Bar');

You can use callbacks for factories. Not that useful right now, but when PHP 5.3 (hopefully very soon) sees the light of day, you can use:

$bucket = new bucket_Container(
  array(
    'pdo' => function($container) {
      return new PDO("mysql:host=localhost;dbname=addressbook", "root", "secret");
    }
  )
);

You can also use a class based factory. This can be combined with callbacks, for overriding methods. Eg. if you create a callback, it takes precedence over the class method. Until 5.3, you’d probably want to write factories as class methods:

class MyFactory {
  function new_pdo($container) {
    return new PDO("mysql:host=localhost;dbname=addressbook", "root", "secret");
  }
}
$bucket = new bucket_Container(new MyFactory());

Support for child scopes. Means that you can create a local container that doesn’t leak state to its parent. Probably not the most important feature for standard web applications, but a nice feature for longer running scripts. Usage is:

$container = new bucket_Container();
$scope = $container->makeChildContainer();

It’s just 153 lines of code, with no external requirements, so go on and grab your copy at: http://github.com/troelskn/bucket/tree/master

/**
 * Interactively prompts for input without echoing to the terminal.
 * Requires a bash shell or Windows and won't work with
 * safe_mode settings (Uses `shell_exec`)
 */
function prompt_silent($prompt = "Enter Password:") {
  if (preg_match('/^win/i', PHP_OS)) {
    $vbscript = sys_get_temp_dir() . 'prompt_password.vbs';
    file_put_contents(
      $vbscript, 'wscript.echo(InputBox("'
      . addslashes($prompt)
      . '", "", "password here"))');
    $command = "cscript //nologo " . escapeshellarg($vbscript);
    $password = rtrim(shell_exec($command));
    unlink($vbscript);
    return $password;
  } else {
    $command = "/usr/bin/env bash -c 'echo OK'";
    if (rtrim(shell_exec($command)) !== 'OK') {
      trigger_error("Can't invoke bash");
      return;
    }
    $command = "/usr/bin/env bash -c 'read -s -p \""
      . addslashes($prompt)
      . "\" mypassword && echo \$mypassword'";
    $password = rtrim(shell_exec($command));
    echo "\n";
    return $password;
  }
}

The company has also released Zend Server Community Edition, a free web application server that is easy to install and use. It is recommended for developers running PHP in a production environment and downloads are available for Windows, Mac and Linux. The package includes:

• Apache 2.2 web server
• PHP
• Zend Optimizer+ (opcode caching and optimization)
• Zend Cache (data and output caching)
• Zend Guard Loader (encoding PHP)
• Zend Framework (PHP libraries)
• Zend Debugger
• Java Server (Java PHP extension)
• Java Bridge (integration of Java libraries in PHP)
• Oracle Instant database client
• IBM DB2 RTCL database client
• MySQL database
• phpMyAdmin (MySQL management tool)

Links:

• Register for the Zend PHP Caching Webinar
• Download Zend Server Community Edition

See also:

• How to Install Apache Web Server on Windows
• How to Install PHP on Windows
• How to Install MySQL
• How to Use MySQL Foreign Keys for Quicker Database Development

Did you attend the Zend webinar? Was it any good? Did you learn anything new about PHP?

Why PHP?

PHP remains the most widespread and popular server-side programming language on the web. It is installed by most web hosts, has a simple learning curve, close ties with the MySQL database, and an excellent collection of libraries to cut your development time. PHP may not be perfect, but it should certainly be considered for your next web application. Both Yahoo and Facebook use it with great success.

Why Install PHP Locally?

Installing PHP on your development PC allows you to safely create and test a web application without affecting the data or systems on your live website. This article describes PHP installation as a module within the Windows version of Apache 2.2. Mac and Linux users will probably have it installed already.

All-in-One packages

There are some excellent all-in-one Windows distributions that contain Apache, PHP, MySQL and other applications in a single installation file, e.g. XAMPP (including a Mac version), WampServer and Web.Developer. There is nothing wrong with using these packages, although manually installing Apache and PHP will help you learn more about the system and its configuration options.

The PHP Installer

Although an installer is available from php.net, I would recommend the manual installation if you already have a web server configured and running.

Manual Installation

Manual installation offers several benefits:

• backing up, reinstalling, or moving the web server can be achieved in seconds (see 8 Tips for Surviving PC Failure) and
• you have more control over PHP and Apache configuration.

Step 1: download the files
Download the latest PHP 5 ZIP package from www.php.net/downloads.php

As always, virus scan the file and check its MD5 checksum using a tool such as fsum.

Step 2: extract the files
We will install the PHP files to C:\php, so create that folder and extract the contents of the ZIP file into it.

PHP can be installed anywhere on your system, but you will need to change the paths referenced in the following steps.

Step 3: configure php.ini
Copy C:\php\php.ini-recommended to C:\php\php.ini. There are several lines you will need to change in a text editor (use search to find the current setting).

Define the extension directory:

extension_dir = "C:\php\ext"

Enable extensions. This will depend on the libraries you want to use, but the following extensions should be suitable for the majority of applications (remove the semi-colon comment):

extension=php_curl.dll
extension=php_gd2.dll
extension=php_mbstring.dll
extension=php_mysql.dll
extension=php_mysqli.dll
extension=php_pdo.dll
extension=php_pdo_mysql.dll
extension=php_xmlrpc.dll

If you want to send emails using the PHP mail() function, enter the details of an SMTP server (your ISP’s server should be suitable):

[mail function]
; For Win32 only.
SMTP = mail.myisp.com
smtp_port = 25

; For Win32 only.
sendmail_from = my@emailaddress.com

Step 4: add C:\php to the path environment variable
To ensure Windows can find PHP, you need to change the path environment variable. From the Control Panel, choose System, (then “Advanced system settings” in Vista), select the “Advanced” tab, and click the “Environment Variables” button.

Scroll down the System variables list and click on “Path” followed by the “Edit” button. Enter “;C:\php” to the end of the Variable value line (remember the semi-colon).

Now OK your way out. You might need to reboot at this stage.

Step 5: configure PHP as an Apache module
Ensure Apache is not running (use “net stop Apache2.2″ from the command line) and open its \conf\httpd.conf configuration file in an editor. The following lines should be changed:

Line 239, add index.php as a default file name:

DirectoryIndex index.php index.html

At the bottom of the file, add the following lines (change the PHP file locations if necessary):

# PHP5 module
LoadModule php5_module "c:/php/php5apache2_2.dll"
AddType application/x-httpd-php .php
PHPIniDir "C:/php"

Save the configuration file and test it from the command line (Start > Run > cmd):

cd \Apache2\bin 
httpd -t

Step 6: test a PHP file
Create a file named index.php in Apache’s web page root (either htdocs or D:\WebPages) and add this code:

<?php phpinfo(); ?>

Ensure Apache has started successfully, open a web browser and enter the address http://localhost/. If all goes well, a “PHP version” page should appear showing all the configuration settings.

See also:

• How to Install Apache
• How to Install MySQL
• MySQL: the Pros and Cons of MyISAM Tables
• MySQL: the Pros and Cons of InnoDB Tables
• How to Use MySQL Foreign Keys for Quicker Database Development

Best of luck!

1. government workers love meetings
2. government workers also love jargon
3. when you combine meetings and jargon, you have excellent conditions for a quick game of Buzzword Bingo*

If you’ve yet to play Buzzword Bingo, you’re missing out on great fun! It’s a game in which you collect buzzwords, clichés, and weasel words, then arrange them in a grid and check them off as you hear them during a particularly wordy meeting. When you’ve checked off a row, column, or diagonal line — bingo!

With just a little bit of beginner PHP and a good collection of jargon words, you can make your own buzzword bingo card that’s randomly generated every time you load the page. Let’s take a look.

(*Buzzword Bingo has a less than worksafe name too, but because we want this newsletter to pass by unimpeded by any cursing filters, I can’t repeat it here.)

Step 1: Create a Function Shell

We’ll be creating a function called Bingo to generate a random buzzword bingo card, which we can then include within a document. Let’s start out by creating a document shell with the Bingo function inside (I’ve called mine bingo.php):

<?php
  function Bingo() {

  }
?>

Step 2: Compile Some Buzzwords

Grab a list of the jargon words or phrases you’d like to see in your bingo cards. You’ll need at least 25 to fill a bingo card, so be sure you have a good collection. I’ve just spent an amusing few minutes strolling around Weasel Words, a site devoted to collecting some horrible examples of managerial speak, and I’ve plucked a bagful of my favorites.

Let’s pop these in an array inside our PHP function:

$buzzwords = array(
  "leverage",
  "synergy",
  "stakeholder",
  "touch-points",
  "knowledge initiatives",
  "cross-organizational collaboration",
  "strategic planning",
  "dynamics",
  "catalyst",
  "values-driven",
  "evangelize",
  "incentivize",
  "loop back",
  "let's take this offline",
  "360 degree thinking",
  "in the pipeline",
  "actioning",
  "paradigm",
  "2.0",
  "going forward",
  "game plan",
  "the end of the day",
  "thought leading",
  "on board",
  "monetize"
  );

Step 3: Do the Shuffle

We want to make sure our card has a random arrangement of buzzwords, so we’ll use PHP’s shuffle function to jumble up the items in the array:

shuffle($buzzwords);

Step 4: Prepare a Table

Bingo is all about filling up rows or columns in a grid, so we’ll use a table to arrange the items.

Let’s create a new variable called $bingocard and start preparing the table markup. You can see I’ve left a gap in the middle — this is where we’ll later put the code that creates the cells and rows.

$bingocard = "<table id='bingo'
summary='A random selection of 25 buzzwords
arranged in a bingo card'>";
$bingocard .= "<thead><tr>";
$bingocard .= "<th>B</th>
      <th>I</th><th>N</th>
      <th>G</th><th>O</th>";
$bingocard .= "</tr></thead>";
$bingocard .= "<tbody>";
$bingocard .= "<tr>";

// here's the gap 

$bingocard .= "</tr>";
$bingocard .= "</tbody>";
$bingocard .= "</table>";

Step 5: Create Cells and Rows

We now need to create 25 cells from the items in our buzzwords array. We’ll use a for loop to iterate through the items in our shuffled array 25 times, and create a table cell for each. That for loop goes in the gap we left in the previous step.

Our table will be a 5×5 grid, so we’ll also need to create five rows, each with five cells. We already prepared the start of our first row and the end of our last row, so we’ll also need to double-check to make sure we don’t do this on the last cell.

To work that out, I’ve used a variable $rowend, which is the remainder of $cell + 1, divided by five. After we create each cell, there’s a small if statement to check whether a $rowend is zero, and that it isn’t the 25th cell. If that’s the case, we’ll close and open a table row element.

Here’s the for loop:

for($cell=0; $cell<25; $cell++)
  {
    $rowend = ($cell + 1) % 5;
    $bingocard .= "<td>" 
     . $buzzwords[$cell] . "</td>";
    if($rowend == 0 && $cell < 24) {
      $bingocard .= "</tr>\n<tr>";
    }
  }

Step 6: Echo the Table

We’ve built an array, shuffled it, and made it into a table. All that’s left to do now is print it:

echo $bingocard;

… and we’re nearly done! You should now have a PHP file that looks similar to Example 1.

Step 7: Drop It in A Document

Let’s now use this function in a web page. Include the bingo.php file at the start of the document:

<?php include ('/path/to/bingo.php'); ?>

Now call on the Bingo function wherever you need to put your card:

<?php Bingo(); ?>

Use some CSS to style the buzzword bingo table how you’d like. You can see a very plain example of a bingo card in Example 2, and the results in Example 3. You might even like to layer on some JavaScript to let players check off each cell by clicking on it, or cause an amusing effect when the player achieves bingo.

Step 8: Play!

When you’re happy with how your card looks, it’s time to pass on the URL of the bingo card to your co-workers. Next time there’s a meeting, print a copy for every player, and see who can call bingo first!