Webmonkey » PHP

Generate PDFs Dynamically With PHP

Webmonkey Staff — Tue, 16 Feb 2010 01:45:47 +0000

PDF is the Portable Document Format developed by Adobe. It’s an open standard implemented by Adobe in their Acrobat series of software, but implementable and extensible by anybody who’s got the time, inclination, and knack. One trick that’s got a lot of potential is using PHP to dynamically generate PDF files and serve them via the web.

PHP can do a lot for your web operation (read our PHP Tutorial for Beginners tutorial). You can generate nice-looking printable receipts, invoices, and brochures. Disc-Cover has a test site that looks up info about a CD automatically and then generates a PDF label for the CD box that you can print, cut out, and use. And there are literally one billion other possible uses for dynamically generated PDFs.

So what are you waiting for?

You have a variety of PDF-generation options. The standard, classic way of doing it is with PDFlib. Because it’s so widely used and well-integrated into PHP, that’s the library I’ll go over today. But it’s by no means the only way of doing things. PDFlib is source-available, but not free. The license specifies that PDFlib can be used and redistributed without charge for non-commercial projects, but commercial use carries a fee.

There are also a number of completely free options. These include R&OS and FPDF, Panda. The choice is yours. (I haven’t had a chance to test these free packages very thoroughly. If you have had negative or positive experiences with them, please do let me know.)

Installing It
Using It
Displaying Text
Wrapping Up

Installing It

In order to install PDFlib, you first have to download the PDFlib source (precompiled binaries are available but they watermark their output). Uncompress the package and compile and install it according to the instructions for your platform. We are assuming that you already have a working build of PHP. Instructions for installing PDFlib are included with the download, but I’ll go over the instructions for Unixy systems (including Mac OS X) anyway.

This article may become dated in terms of version and patch information. In general, it’s a good idea to download the PDFlib on PHP manual (PDF link) and read the most current instructions before installing PDFlib.

Install all the files in their appropriate places according to the instructions.

In your PHP directory, rebuild the configure file:./buildconf

Rebuild PHP, adding the switch --with-pdflib=PDFDIR (change PDFDIR to the name of the directory where PDFlib is installed).

Restart Apache, and there you go.

Using It

PDFlib, in conjunction with PHP, has over a hundred functions available for creating PDFs. To conserve time, space, and sanity, I’ll only cover a few of these. The full gamut is explained both on the PHP site and in the documentation that accompanies the PDFlib download.

Let’s zip through a step-by-step explanation of creating a new PDF document. Nothing fancy, just a couple of lines of text on a page. To start with, we need to initialize a new PDF object with the pdf_new() function. We will assign the object to the variable $pdf. This object handle is how we’ll refer to the PDF we’re creating from now on.

  $pdf = pdf_new();

Next we want to create a new blank PDF file. This is done with the PDF_begin_document() function. We tell it the name of the PDF object we’re working with:

  PDF_begin_document($pdf);

Moving swiftly along:we’ve got a PDF object containing one blank PDF file. Now we start to fill it in. First let’s set the metadata fields for the PDF. This step is optional. Every PDF has header information in which the document title, creator, and so forth can be specified. We set this data with the pdf_set_info() function. This function takes three arguments:the PDF object we’re working with, the name of the property we want to set, and the value we want to set it to. The predefined property names you can use are Author, Creator, Keywords, Subject, and Title. So, for example:

  pdf_set_info($pdf, "Author", "Paul Adams");

Next we create the first page of our PDF, specifying width and then height, in points. A point is 1/72 of an inch, so if we want an 8.5-by-11-inch page, we do a little multiplying:

  pdf_begin_page($pdf, (72 * 8.5), (72 * 11));

(If you are following along with pencil and paper, you will see that we could have substituted “612″ and “792″ for the width and height terms.)

Now we’ve got everything set up. Next, let’s get to the meat of our PDF:the content. First we need to choose a font to display our text. This is a two-step process:locating the font, and then using it. The PDFlib manual is very helpful on this topic.

Displaying Text

This section covers the use of a depricated function. Please help us keep Webmonkey up to date by editing it.

The function we use to locate and prepare the font is pdf_findfont(). It takes four arguments:the PDF object handle, the font name, the encoding of the font, and whether or not the font should be embedded in the document. We are going to use one of the 14 fonts built in to PDFlib, which means we don’t have to get our hands too dirty. It means we don’t have to embed the font (which we indicate by a “0″ value for the last argument), and the encoding is “host”. These 14 fonts are (still have that pencil ready?):Courier, Courier-Bold, Courier-Oblique, Courier-BoldOblique, Helvetica, Helvetica-Bold, Helvetica-Oblique, Helvetica-BoldOblique, Times-Roman, Times-Bold, Times-Italic, Times-BoldItalic, Symbol, and ZapfDingbats. For our text we’ll use Times-Roman, okay? pdf_findfont() returns a font handle, which we’ll pass to the $font variable:

  $font = pdf_findfont($pdf, "Times-Roman", "host", 0)

If something goes wrong, the font handle $font will be set to “FALSE”. But nothing ever goes wrong. Part Two is to tell the renderer that we want to use that font, and to specify the size in points, with:

pdf_setfont().



  pdf_setfont($pdf, $font, 16);

Now we’re almost ready to print our text. We just need to set the position for it to appear, with pdf_set_text_pos(). With this function, we specify an X and Y coordinate in points, counting from the lower left corner of the page, which is (0,0). Let’s print our text near the upper left of the page:

  pdf_set_text_pos($pdf, 72, 720);

pdf_show() is used to print text at the current position. Its usage is very simple:

  pdf_show($pdf, "My First PDF Document");

There’s the text! At last! At this point, if we wanted, we could continue to move around the page, printing more text in various fonts, drawing images, adding new pages, and so forth. But I think we’ve covered about enough for an intro course. Let’s close things down.

Wrapping Up

We end the page with the pdf_end_page() function:

  pdf_end_page($pdf);

and then close the object:

  pdf_end_document($pdf);

The complete PDF document that we’ve created is now neatly put away in the PHP buffer. In order to display or save it, we need to fetch it from there and do something with it. The pdf_get_buffer() function gets the contents of the buffer and puts it into a new variable.

  $document = pdf_get_buffer($pdf);

Now let’s create a new PDF — just kidding. Actually we can’t use any more PDF functions until we get rid of this object we’ve just pulled from the buffer. That’s a safeguard built into the system. We must either send the PDF to the user’s browser, save it as a file on the server, or delete it from memory. Let’s do the latter two.

To display it, we need to first send HTTP header information, to let the browser know what’s coming. This is done with the header() function. We need to send three headers:Content-Type, Content-Length, and Content-Disposition.

First let’s find the length of the PDF, and give it a filename:

 $length = strlen($document);



  $filename = "myfirstpdf.pdf";

Then we output the headers:

  header("Content-Type:application/pdf");



  header("Content-Length:" . $length);



  header("Content-Disposition:inline; filename=" . $filename);

Now we’re ready to send the actual document to the browser, with a simple echo() function:

  echo($document);

All set. Finally, as a last step, we purge the memory to get ready for our next adventure:

unset($document);



  pdf_delete($pdf);

Here is a look at all that code assembled in one place:

That’s kind of a lot of code to print one line of text, it’s true. But that was just an example. The PDF format wasn’t invented for displaying single lines (although it does them so nicely!). You can use the framework above to output all kinds of complex PDFs, with logos and diagrams and color and links and whatever. There are simple PHP functions for all that stuff. Just start small and work step-by-step. The PDFlib package includes a very cool demo, called pdfclock, of an analog clock rendered as a dynamic PDF. See where that leads you. Follow your heart.

PHP and MySQL Tutorial – Lesson 3

Webmonkey Staff — Tue, 16 Feb 2010 01:45:47 +0000

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.

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 echo $title ?>

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.

n";

echo "NamePositionn";

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

  printf("%s %s%sn", $myrow[1], $myrow[2], $myrow[3]);

}

echo "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.

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.

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.

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:

 
 

 ";

 	echo "The reported error was $error.n
";

 	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);

 }

 ?>

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:

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.

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!

Be Your Own Open ID Provider

Webmonkey Staff — Tue, 16 Feb 2010 01:45:47 +0000

OpenID is a burgeoning standard for identifying and authenticating yourself on the web. You do this by identifying yourself not with a standard username and password, but with a URL. This URL points to a web page that verifies that you are, in fact, you.

A number of third-party sites offer OpenID URLs to their users, including LiveJournal, AOL, and Technorati. But some people do not like to be beholden to third parties for something that may turn out to be a central part of their online identity, and they’d rather host their own.

An easy way to do that is with an open source PHP identity server called phpMyID.

What You’ll Need
Installing phpMyID
Using It
Further Reading

What You’ll Need

A web server running PHP

An MD5 hashing tool, such as md5sum on Unix or Cygwin or md5.exe on Windows

Installing phpMyID

Download the latest source from http://siege.org/projects/phpMyID/. Create a subdirectory in your web directory called phpmyid. Place the files MyID.config.php and MyID.php in that directory, setting their ownership to the web user, if necessary.

In your web browser, go to http://yourwebserver/phpmyid/MyID.config.php. The page should display.

This is an OpenID server endpoint. For more information, see http://openid.net/



Server: http://yourwebserver/phpmyid/MyID.config.php



Realm: phpMyID



Login

If you click the Login link, it’ll prompt you for a username and password, which you haven’t yet configured yet. To do that, you need to come up with a username and password, then create an MD5 hash of them.

To do this at a Unix command line with OpenSSL, feed the username and password you want to the md5sum utility in the format username:phpMyID:password. Replace “phpMyID” with the realm from above if your realm differed:

echo -n "username:phpMyID:password" | md5sum

The output will be a 32-character hexadecimal hash that looks like:

22a204f0bf622e4a35f3d71304378ca9

You must memorize this — Ha, only kidding. Just copy it and be ready to paste it.

On Windows, feed the same username:phpMyID:password string into the MD5 hasher you’re using.

Now open the file MyID.config.php in a text editor. Near the top are two lines:

    'auth_username' =>  'test',



    'auth_password' =>  '22a204f0bf622e4a35f3d71304378ca9

Replace 'test' with the username you chose, and replace the 32-character hash that’s there with the hash you just generated.

Now when you click Login, enter your new username and password into the prompt. If you did everything correctly, it should tell you “You are logged in as username”.

Using It

Now, to use this as your OpenID, you’ll need a URL that points to it. Choose an HTML page under your control — say, the front page of your site — or create a new one. Add these two lines inside the head of that page:

Now, when you want to authenticate, simply give that page’s URL. It’ll prompt you for your username and password and then authenticate you.

Drupal’s Creator Envisions Web Publishing’s Plug-and-Play Future

Michael Calore — Thu, 19 Jun 2008 22:29:01 +0000

Dries Buytaert started down his path to fame when he coded up a private message board for his college dormitory. Nine years later, that modest bulletin board software package has grown into Drupal, one of the most popular open-source content publishing systems on the web with thousands of active contributors. In March 2008, Buytaert connected with entrepreneur Jay Batson, and together the two of them founded Acquia, a commercial venture that will provide technical support for Drupal’s devotees as well as further the adoption and development of the platform.

Webmonkey sat down with Dries and Jay to talk about the history of Drupal, where development is headed and the role their new company will play in the project’s future.

Photos: Jim Merithew/Wired

Webmonkey: Dries, can you give us Drupal’s back-story? The germ of the idea and how the platform grew into existence?

Dries Buytaert: It sort of happened by accident. I was a student at the University of Antwerp in Belgium around 1999. I was doing web development with CGI and server-side includes, but I wanted to learn more about technologies like PHP and MySQL. Also, at the same time, we had the need for an internal messaging system at our student dorm. So, I wrote a simple message board. Then when I graduated, I decided to move my internal message board onto the internet.

When I registered a domain for it, I wanted to register the name “Dorp,” which is Dutch for “small village.” But I mis-typed, and actually ended up registering the name Drop. Amazingly, Drop.org was still available, and since it’s an English word with multiple meanings, I decided to just go with it.

Our original user community died pretty quickly, but I continued working on it by adding things like RSS feeds and the ability for users to rate content. More and more people started coming to the site with ideas and suggestions, like ways to modify the algorithm that handles comment moderation. At a certain point, I was getting so many suggestions that I decided to just open up the source code. That was the Drupal 1.0 release, which came out in early 2001.

At the time of the release, I was fairly confident that I had a good system. I felt that it was competitive with the other open source technologies out there like PHP-Nuke. So, it felt like the right thing to do.

Webmonkey: One of the key pieces of Drupal’s design is its modularity — users install a core package, then add functionality by installing task-specific modules. Where did the idea for the modular design originate?

Buytaert: It was part of the initial design. I was sort of shocked that most of the other systems didn’t have a modular design — to me, with my background as a computer science student, that felt like a very natural thing to do. I was also involved in the Linux kernel back then, working on wireless network drivers. That’s also obviously a modular system, so I may have gotten some inspiration from there as well.

Jay Batson: Speaking as somebody who dealt with a lot of content management systems before meeting Dries, I can say that most of the other CMS’s out there didn’t come from people who were computer science grad-types. They were built by web designers or programmers who maybe were self-taught and had hacked together a system that sort of worked. They didn’t come from people with an underlying discipline of computer science. That ended up being a key distinction between Drupal and other systems.

Webmonkey: Drupal is especially popular with those who want to build a site around some sort of central social networking component. Is that because it gives such granular control over user management, or is it because Drupal became popular at the same time social networks were really taking off?

Buytaert: I think the first reason is definitely a big part of it. Drupal was a multi-user system from day one, but most of the other systems are behind Drupal as far as user management and access rights.

It’s a very social system by design. For example, the original Drop.org site was very much like Digg, where people could submit links and vote on each other’s submissions. Such user interaction was a key initial feature of Drupal. Over time, we’ve been moving away from these features. That voting system has since been taken out of the core, but it’s available in a module. Instead we’re evolving into a platform that can do more — the traditional web content management stuff as well as the social stuff.

Batson: They also got a good boost because Drupal 5 had as its tag line “Community Plumbing.” At that moment in time when community-based sites were becoming more important, here was this system marketing itself as being optimized for that.

Also at that time, there were a lot of people coming into the Drupal community and contributing code. So, a great deal of code was written in that area with the social features in mind. I know Dries was spending most of his time during that period managing those contributions — keeping the Drupal core slim, but making sure that the key features were there. And, at the same time, stressing the importance of modules.

Buytaert: One of the things I’ve always encouraged people to do was take Drupal in different directions. I think it’s a very powerful notion to get out of people’s way. So if they want to build a social networking site or a Flickr clone, I think it’s important that Drupal as a platform is capable of serving all these different needs. That’s what the modular design helps accomplish.

Webmonkey: Tell us about Acquia, the company you founded together.

Batson: Our goal is to become to Drupal what Red Hat and Canonical are to Linux. If you want a supported version of this open-source software, you come to us and pay a subscription. You get a distribution, a set of services for maintenance and updates plus access to our tech support center. So let’s say you’re running a large-scale media site and you’ve built all of your front-end infrastructure on Drupal. You need an answer about something, and you want the ability to pick up the phone and have an answer within an hour rather than send an e-mail and wait a day, or wait for the appropriate person to log in on IRC. On the other end of the spectrum is the small site that needs help with installing modules or managing updates. It’s a well-proven open-source business model.

The other role we can play at Acquia is supporting the Drupal development community. Drupal has wonderful organic growth. The community is roughly doubling every year. That’s impressive, but we’d like to see it grow by a factor of ten.

Webmonkey: How many developers are working on Drupal right now?

Buytaert: For Drupal 6, the last major release, we had around 900 people contribute to the core. As a reference, that’s the same number of people who contribute to the Linux kernel. There are over 2,000 contributed modules, and each of these modules has one or more maintainers. The Drupal.org website has between 250,000 and 300,000 registered users. These are not necessarily all developers, but those people are participating in the community in some way.

Webmonkey: Where is Drupal development going next?

Buytaert: We are working on Drupal 7 right now. We’ll have a better database abstraction layer, better support for WYSIWYG tools and usability improvements for admins that make it easier to configure Drupal.

We have a new core feature called Content Construction Kit, or CCK. This lets you define new types of content using a web interface. For example, if you have a bicycle website and you want your users to be able to share their favorite rides, you can create a new content type called “rides.” That content type might include a start location, an end location, a link to a Google map, some pictures of the route, text describing the ride. Once you have all of this data, you can choose to visualize the ride on a Google map, or display it all in a table or whatever you want. Many different views can be extracted from this big bag of user data, and it can all be accomplished using an easy web interface.

Our long-term vision for Drupal as an open-source project to fully democratize online publishing — to make it possible for everyone to create really powerful and interesting websites just by clicking around. Drupal lets you get a working prototype up and running in just a couple of hours without having to write any code. That’s very powerful.

Webmonkey » PHP

Generate PDFs Dynamically With PHP

Contents

Installing It

Using It

Displaying Text

Wrapping Up

PHP and MySQL Tutorial – Lesson 3

Simple Validation

Not-So-Simple Validation

Functions

Closing Advice

Be Your Own Open ID Provider

Contents

What You’ll Need

Installing phpMyID

Using It

Further Reading

Drupal’s Creator Envisions Web Publishing’s Plug-and-Play Future