VOLUME III - ISSUE 12
DECEMBER 2004
TM
The Magazine For PHP Professionals
Design patterns
Modelling Object Applications
Powerful Solutions to Common Problems
Using UML
Integrating SAP with PHP
Simplified MVC for PHP Web Apps
in PHP 5
www.phparch.com
Power and cost effectiveness
Mobilizing Web Content
Tick functions
Write Once, Wireless Anywhere
Uncovering How PHP "Ticks"
A look at serving multiple devices with a single codebase
Get Ready for: This copy is registered to: livia carboni jackson
[email protected] TABLE OF CONTENTS
php|architect
TM
Departments
I N D E X
6
Features 10
Editorial The Most Wonderful Season of All
16
7
Tick functions Uncovering how PHP “Ticks” by Michael Paul Bailey
Design Patterns Powerful Solutions to Common Problems by Devon Weller
What’s New! 23
Mobilizing Web Content by Roland Schmidt
50
Product Review EngInSite PHP IDE by Peter B. MacIntyre
63
31
A Simplified MVC Pattern for PHP Web Apps Building Modularized Content Management Apps Using a Controller Script, Screen Classes and Data Objects by Lukasz Karapuda
Security Corner Cross-Site Request Forgeries by Chris Shiflett
42
Integrating SAP with PHP by Jason Simmons
67
54
exit(0); A Wish for PHP 6 by Andi Gutmans and Marco Tabini
December 2004
●
PHP Architect
●
www.phparch.com
Modeling Object Oriented Applications Using UML in PHP5 by Pawel Pastuszak
4
EDITORIAL
The Most Wonderful Season of All
I
php|architect
TM
Volume III - Issue 12 December, 2004
E D I T O R I A L
R A N T S
like December. This year, I have three reasons to celebrate: first, it’s
Christmas, which means I can take two weeks off—a luxury I can afford at no other time of the year. Second, this will be the first year I spend with my son (at least, the first year in which I won’t be so sleep deprived to wake up on Christmas morning, my hands still clutching a wrapped present I was waiting on midnight to open). Third, and most important for this editorial, php|architect celebrates its second anniversary. It is estimated that most magazines never make it past the eighteenmonth mark. Well, here we are, on our twenty-fifth issue, still alive and kicking! I remember, in the few weeks after we published our first issue, reading on a forum somewhere that people (after getting past the shock of a PDFonly magazine) were wondering whether we’d be able to keep up the pace and avoid running out of ideas every few issues. I have to admit that there were a few times when planning php|a that I wondered about that myself; but, as it turns out, not only we never ran out of ideas—and I still see new articles commissioned on a regular basis on topics that I couldn’t have thought of in a million years. Of course, when I say “we” I really mean “our authors and columnists,” without whom it would be nearly impossible to keep php|a thriving. To them, I dedicate our second anniversary issue. On a slightly different topic, you’ll see that, despite December being a month for holiday and relaxation, we’re doing just about anything except for sitting still. Just last month, we launched Marco’s Wonky Math (http://www.phparch.com/wonky), an excellent set of promotions made at my expense. In December, we’ll pair them up with php|architect’s Seven Days of Christmas (http://www.phparch.com/sevendays)—and believe me when I say that you should watch out for these deals. Incidentally, I regularly receive e-mails from subscribers to our print edition who lament the fact that, due to the vagaries of the postal service, they always end up finding out about our promotions after they’ve run out. I understand you; I have the same problem with some of the magazines I receive from Europe. However, not all is lost. We’ve decided to create a mailing list exclusively with the purpose of letting all interested readers about our offers in a timely manner. You can sign up for this mailing list at the Seven Days of Christmas page—and, in the future, we’ll use it to let you know about new deals, such as the really big one that’s coming in January (I could tell you, but the rest of the team will probably kill me if I did). You don’t have to be a subscriber to sign up for the mailing list, of course. Just make your way over there and get your name in the hat. We won’t sell the list (ever) and you can remove your address at any time. Finally, our big news this month is php|tropics. Last year, we took a crowd of PHP enthusiast on a five-day cruise across the Caribbean islands. This year, we’re taking you (yes, that means you!) on a five-day conference in a beautiful resort in sunny Mexico. Trust me, this is one experience you don’t want to miss. You can find out more information and sign up right now at http://www.phparch.com/tropics. In fact, if you sign up before December 31st, you may even be able to write the conference off your 2004 taxes—can’t get much better than this. Until next month, happy holidays (and happy readings, of course!).
Publisher Marco Tabini
Editorial Team Arbi Arzoumani Peter MacIntyre Eddie Peloke
Graphics & Layout Arbi Arzoumani
Managing Editor Emanuela Corso
News Editor Leslie Hill
[email protected] Authors Michael Paul Bailey, Lukasz Karapuda, Peter MacIntyre, Pawel Pastuszak, Roland Schmidt, Chris Shiflett, Jason Simmons, Devon Weller
php|architect (ISSN 1709-7169) is published twelve times a year by Marco Tabini & Associates, Inc., P.O. Box 54526, 1771 Avenue Road, Toronto, ON M5M 4N5, Canada. Although all possible care has been placed in assuring the accuracy of the contents of this magazine, including all associated source code, listings and figures, the publisher assumes no responsibilities with regards of use of the information contained herein or in all associated material.
Contact Information:
[email protected] General mailbox: Editorial:
[email protected] Subscriptions:
[email protected] Sales & advertising:
[email protected] Technical support:
[email protected] Copyright © 2003-2004 Marco Tabini & Associates, Inc. — All Rights Reserved
December 2004
●
PHP Architect
●
www.phparch.com
6
NEW STUFF
What’s New! S T U F F
php|architect launches php|tropics 2005 Ever wonder what it's like to learn PHP in paradise? Well, this year we've decided to give you a chance to find out! We're proud to announce php|tropics 2005, a new conference that will take place between May 11-15 at the Moon Palace Resort in Cancun, Mexico. The Moon Palace is an allinclusive (yes, we said all inclusive!) resort with over 100 acres of ground and 3,000 ft. of private beach, as well as excellent state-of-the-art meeting facilities. As always, we've planned an in-depth set of tracks for you, combined with a generous amount of downtime for your enjoyment (and your family's, if you can take them along with you). We even have a very special early-bird fee in effect for a limited time only. For more information, go to http://www.phparch.com/tropics.
php
PHP 4.3.10 RC 1 released!
4.x
PHP.net is proud to announce the release of 4.3.10 RC 1 “PHP 4.3.10RC1 has been released for testing. This is the first release candidate and should have a very low number of problems and/or bugs. Nevertheless, please download and test it as much as possible on real-life applications to uncover any remaining issues.”
N E W
Get the latest release from http://www.php.net.
php
PHP 5.0.3RC1 released
5.x
From php.net: "PHP 5.0.3RC1 has been released for testing. This is the first release candidate and should have a very low number of problems and/or bugs. Nevertheless, please download and test it as much as possible on real-life applications to uncover any remaining issues." For more information visit: http://www.php.net/
Take Advantage of Marco’s Wonky Math and Save Up to $80 Our fall/winter 2004 subscription campaign is in full effect—and this year we have some great offers for all our subscribers, regardless of whether you’re becoming a member of our family for the first time or if you’re been looking forward for your copy of php|a since the very beginning. Signing up for a php|a subscription (or adding another 12 months to your existing one) right now means some great offers, which include: • A $80 discount on the Zend Certification Guide • A free 64MB USB Memory Key, complete with the php|architect logo For more information, visit our website at http://www.phparch.com/wonky
December 2004
●
PHP Architect
●
www.phparch.com
7
NEW STUFF
Maguma Workbench 2.1 The Maguma Team announces the release of Maguma Workbench version 2.1 “Version 2.1.0 represents the latest in the Workbench series offered by Maguma GmbH. This PHP IDE gives the user features like: debugging support via Xdebug, modular plugin architecture for easy extensibility, remote file editing both with FTP and SFTP. [The product is d]ownloadable from http://www.maguma.com/ with a 30-day trial license. The main issues addressed by this release are stability, PHP5 support, and remote file support. With the user community promptly reporting any problems occurring we have been able to aggressively remove roadblocks to the efficient development of PHP applications with Workbench.” This version also offers some long awaited features requested by users. You can find the changelog at http://support.maguma.com/?article=changelog210 For more information visit: http://www.maguma.com/
PHPReports 0.3.5 Want to add reporting capabilities to your PHP application and need some help to get started? Check out the latest release of PHPReports. “Phpreports is a PHP report generator that uses XML report layout files to generate PHP code and create reports in output formats like HTML and TXT.” Get more information from http://phpreports.sourceforge.net/
PhpMyLibrary 2.0.3 PhpMyLibrary is now available for download. “phpMyLibrary is a PHP MySQL Library automation application. The program consist of cataloging, circulation, and the webpac module. The program also has an import export feature. The program strictly follow the USMARC standard for adding materials.” For more information visit: http://www.phpmylibrary.org/
Check out some of the hottest new releases from PEAR.
UDDI 0.2.0alpha4 Implementation of the Universal Description, Discovery and Integration API for locating and publishing Web Services listings in a UBR (UDDI Business Registry)
Net_DNSBL 0.5.1 Checks if a given Host or URL is listed on an DNSBL or SURBL
XML_Transformer 1.1.0 The XML Transformer allows the binding of PHP functionality to XML tags to transform an XML document without the need for and the limitations of XSLT.
XML_Serializer 0.13.1 XML_Serializer serializes complex data structures like arrays or object as XML documents. This class helps you generating any XML document you require without the need for DOM. Furthermore, this package can be used as a replacement to serialize() and unserialize() as it comes with a matching XML_Unserializer that is able to create PHP data structures (like arrays and objects) from XML documents, if type hints are available. If you use the XML_Unserializer on standard XML files, it will try to guess how it has to be unserialized. In most cases it does exactly what you expect it to do. Try reading a RSS file with XML_Unserializer and you have the whole RSS file in a structured array or even a collection of objects, similar to XML_RSS. Since version 0.8, the package is able to treat XML documents like the simplexml extension of PHP 5.
Net_IPv6 1.0.1 The class allows you to: • check if an address is an IPv6 address • compress/uncompress IPv6 addresses • check for an IPv4 compatible ending in an IPv6 adress
December 2004
●
PHP Architect
●
www.phparch.com
8
NEW STUFF
Looking for a new PHP Extension? Check out some of the lastest offerings from PECL
translit 0.4 This extension allows you to transliterate text in non-Latin characters (such as Chinese, Cyrillic, Greek etc) to their Latin counterpart. Besides the transliteration, the extension also contains filters to upper- and lower-case Latin, Cyrillic and Greek, and perform special forms of transliteration, such as converting ligatures such as the Norwegian “æ” to “ae” and normalizing punctuation and spacing.
pdflib 2.0.3 This extension wraps the PDFlib programming library for processing PDF on the fly, created by Thomas Merz. PDFlib is available under the PDFlib Lite License (http://www.pdflib.com/pdffiles/PDFlib-Lite-license.pdf) and for commercial licensing.
coin_acceptor 0.3 This module let you control your local coin acceptor, using a serial connection and the simple management protocol. This module supports four-slot coin acceptors using the ABCD method to control them.
WinBinder 0.31.104 WinBinder is a new PHP extension that allows PHP programmers to build native Windows applications. It wraps the Windows API in a lightweight, easy-to-use library so that program creation is easy, quick and fun.
phpCMS 1.2.1 pl1 phpcms.de announces the latest release of the PHP Content Management System which “convinces in particular by small system requirements, high performance and above all its flexibility.” The phpcms site announces: “we released version 1.2.1pl1 of phpCMS because Cyrille Barthelemy found a cross-site scripting vulnerability in version 1.2.1. It is likely that this bug is also found in previous versions. The bug is only exploitable in non-stealth mode with debug mode enabled.” Get all the latest info by visiting: http://phpcms.de/
PHP Web Toolkit 1.0.3 phpwebtk.sourceforge.net announces: “It is with my great pleasure and privilege to announce the availability of the PHP Web Toolkit Version 1.03. Many new enhancements and features have been implemented, such as htmlArea, kses and Smarty integration to name a few. Therefore, this release marks a significant milestone and is now a much more useable framework and toolkit compared to previous versions. What does the future hold for the PHP Web Toolkit? Stay tuned and check out the Docs section of the project. Finally, I encourage everyone to submit bugs, feedback and suggestions. Enjoy!” What is it? “The PHP Web Toolkit enables the rapid development of multi-layered web applications and is designed to be easy to use, extensible, reliable, reusable, scalable and secure.” Get more information from phpwebtk.sourceforge.net
Php.net has a new post to announce PHP West Conference PHP West is holding a conference on Web Services on January 14th, 2005 hosted in the beautiful Vancouver, British Columbia, Canada. This is the first of many conferences to come on a four month orbit – each focusing on a unique genre. The conference will be a jam packed one day event with the most important topics PHP developers are faced with regarding Web Services. The conference has received talks from leading speakers in the industry – speakers which have been chosen will be announced on December 16th. Early bird special tickets are available until December 26th and due to limited capacity for this event the organizers recommend you register soon to reserve your seat. Online registration is now open! For more information visit: http://www.php.net
php|architect's Seven Days of Christmas: Seven Special Deals for the Holidays! The holiday spirit is in full force here at php|a headquarters, and we thought we'd send some of the cheer over to our readers as well. Therefore, starting from December 15th, we'll be setting up a new special deal every day for one week. From discounts on subscriptions (great for extending your stay with us even if you have one already) to great deals on Zend Certification products and much, much more, we've got you covered. Find out more information and join our mailing list at http://www.phparch.com/sevendays
December 2004
●
PHP Architect
●
www.phparch.com
9
FEATURE
Tick functions Uncovering how PHP “Ticks”
F E A T U R E
by Michael Paul Bailey
So they say that PHP does not support multithreading. Well… they’re right, but it does offer something similar.
L
et’s face it: everyone has some skeletons in their closets. For example, when I was ten I stole some baseball cards with a friend of mine and was never caught. I would be mortified if anyone were to discover that secret. PHP is no different. It has some deep dark secrets that it doesn’t want anyone to know about and does a good job at keeping hidden. This is the reason why, at parties, you always find PHP standing between the punch bowl and the flashing green exit sign, prepared to make a hasty getaway if necessary. PHP is always a little nervous someone like Python might sidle over and bring up an awkward topic like multithreading. It’s not that PHP is embarrassed about its lack of multithreading, mind you—what really scares PHP is that someone will discover its big secret, tick functions. Bringing up this topic would cause PHP to dash from the room so quickly that everything would get really quiet and the party would turn a bit awkward for a few minutes. As a wise man once said, “The truth shall set you free.” To this end, we’re going to take a look at a little known tool available to PHP developers—namely, tick functions. Although PHP lacks a real threading API, it has the next best thing: an awkward system of executing callback functions at specified intervals, called tick func-
December 2004
●
PHP Architect
●
www.phparch.com
tions. Internally, the PHP engine provides a mechanism for generating ticks after a given number of low-level statements. Functions can then be registered to fire every time PHP generates one of these ticks. This provides a way to break the execution of our script automatically to execute other commands. Registering Tick Functions Luckily for us, when dealing with tick functions, we do not have a long list of functions to worry about. There are only two functions and one bizarre flow control construct, which we will explain below. The two functions, register_tick_function() and unregister_tick_function(), are our first concern. Though the names are fairly self-explanatory, let us examine each one briefly. register_tick_function() marks a callback function to be executed for each tick. It accepts any number of parameters, though it only requires one. The first parameter must be a valid callback function. Any of the usual ways of passing a callback functions will suffice:
REQUIREMENTS PHP: 4.3+ OS: Any Other Software: N/A Code Directory: Ticks 10
FEATURE
Uncovering how PHP “Ticks”
the name of a global function, an array containing an object and the name of a member function of the object, or an array consisting of a class name and a static member function of the given class. The selected function will then be called whenever a tick occurs. Optionally, register_tick_function() can also receive any number of additional parameters, which are passed directly into the callback function upon execution. This provides two additional benefits: first, passing extra parameters allows us to call a function in multiple ways. One parameter might imply that the function is being called in response to a tick, while another can be used to specify a normal call. Second, we can call system functions and pass the given parameters to them. If register_tick_function() is called multiple times, the order in which the functions are registered is the order in which they will be called. Thus, the function given in the first register_tick_function() call is executed first, then the next and so on. unregister_tick_function() removes a previously registered tick function. It only accepts one parameter, a valid callback function (as defined above). This parameter needs to match the callback function passed to register_tick_function() in order to properly unregister the correct function. If the parameter matches more than one tick function, the one that was registered first is removed. For this reason, you should avoid registering the same tick function twice, as there is no way to differentiate between each particular instance when unregistering. Both register_tick_function() and unregister_tick_function() act on the global context. If called within a function, the tick function is registered or unregistered throughout the remainder of the script.
The declare Construct Listing 1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
December 2004
●
PHP Architect
●
www.phparch.com
The last part of the tick function API is the declare construct. This could very well be the most bizarre thing I have ever found in PHP. It is not a function. It is not really a flow control statement. It bears more resemblance to a pre-processor directive in C++ (ie #pragma or #ifdef). The PHP manual states that the declare construct gives the ability to control certain execution directives. The directive is placed within parenthesis immediately following the declare keyword. The scope of the declare construct is defined by bracing the block of code to which it applies. Alternatively, you may terminate the call with a semicolon in place of braces. This causes the declare statement to take effect on the remainder of the script. We use the declare construct to set the ticks directive, which specifies how many low-level statements are executed between each tick generation by the engine. The syntax is a little different. Within the parenthesis following the declare keyword we write the word “ticks” followed by an equals sign and the number (see any of the code listings for an example). This must be an actual number—variable interpolation is not allowed. Setting ticks to zero causes ticks to stop being generated. declare is absolutely necessary. When a script begins executing, ticks are not generated. We can call register_tick_function(), but the function does not get called until a declare statement is given, at which point ticks begin to be generated. Simple Example Now that I’ve finished making no sense whatsoever, let’s take a look at a simple example of how this all comes together. As you can see in Listing 1, our first step is to define a tick function, which does nothing more than print the word TICK. Four examples are given to show the effects of the different functions and directives. For loops simulate a block of code with a number of different statements. Each step of each for loop prints a letter followed by the iteration number. This will allow us to see how the tick function effects the execution. The first example calls register_tick_function() to register tick(). Notice that all of the A iterations are printed together. While a tick function has been registered, the declare construct has not yet been called, so the engine is not generating any ticks. The second example starts by setting the ticks directive to one. As a result “TICK” separates every two lines of the B iterations. The tick function is firing properly. Next the ticks directive is changed to three. The C iterations are still interspersed with the word “TICK” but not as frequently as the previous example. The ticks are only being generated after every three low-level statements. The last example starts by unregistering the tick func-
11
FEATURE
Uncovering how PHP “Ticks”
tion with unregister_tick_function(). Although the PHP engine is still creating ticks, no callback functions are registered to handle them, so no “TICK” messages appear in the D iterations. Real-world Solutions Now that we’ve seen a brief example of how tick functions operate, let’s look at some real-world problems that can be solved using them. Tick functions are distinct from many other parts of PHP in that they do not just provide shortcuts to already solvable problems— they provide solutions to previously unsolvable ones. For example, print_r() is a nice function, but we could do without it—it would just take a little extra work to format all the output. Tick functions, on the other hand, can do things that nothing else can accomplish. The following examples are taken from real problems I have dealt with in the recent past. They will hopefully show how tick functions can actually solve real world problems. Auto-Saving There are many scripts that can take a long time to run. When executing a script of this nature, the ability to pause and resume is a must, especially during the debugging phase. Tick functions can provide a simple method of saving a script’s state automatically so that Listing 2 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
December 2004
●
PHP Architect
●
www.phparch.com
execution can be resumed at a later point. Recently, I was working on a spider script that builds a database by parsing web pages from a remote site. The script’s execution was dependent upon a queue: whenever a new web page was identified for parsing, its URL was added to the queue. By traversing the queue, the script was able to hit all of the necessary web pages without resorting to recursion. Spidering a large site could take upwards of hours. Unfortunately, if a bug appeared or I needed to pause the script for some reason, I had to start all over again from the beginning. Therefore, I wrote a tick function that would automatically save the queue every few seconds.
Listing 3 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
12
FEATURE
Uncovering how PHP “Ticks”
Listing 2 provides the framework for just such a system. First, the object that contains the script’s state information must be defined. In this example, we will use the class AutoSaveObject. The variable $num represents the possible data the object would contain in a real situation—such as, for example, a queue containing the URLs of the pages that need to be crawled. The variable $volatile is in place to flag an object as “unsaveable”. There are certain states in which saving an object may be unwise (e.g.: in the middle of a calculation). Setting $volatile to true will cause autosave() not to save the object. Following the class, we have our auto-save function, which does the actual writing of the data: the object is converted to string using serialize() and saved to a file. Next, we load the object, or create it if the file does not exist. Then we register autosave() as a tick function and declare the ticks directive. In this simple example, the main section of our code does nothing more than increment the member variable $num. If you run the listing, halt it and run it again, you will see that the counting begins where it left off each time. Deleting the auto-save file (obj.dat) resets the script. The auto-save frequency can be adjusted by changing the tick directive value. A lower value will cause saves to occur more frequently, but it will also result in slower execution. Process Control PHP has come a long way from its initial roots as a language for programming websites. I have now begun using PHP as my primary shell scripting language as well. One very important tool when building shell scripts is the ability to accept process control signals, like SIGHUP and SIGTERM. PHP provides an extension for handling process control signals, the pcntl extension. Listing 4 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
December 2004
●
PHP Architect
●
www.phparch.com
Since PHP 4.3.0, the way it watches for these signals is using tick functions. Although you need not register your own tick functions, you must use declare to set the ticks frequency. You then define which signals you wish to listen for and a function to handle them. The pcntl extension then internally sets up a tick function to watch for the given signals. This same idea can be used for handling other userdefined external signals, like watching for a file to finish downloading or for a process to complete. I recently used this as a way of running multiple MySQL queries simultaneously and handling the result set. Unfortunately, that goes beyond the scope of this article. Function Profiling Recently, I was working on an optimization project. Our product was experiencing some bottlenecks that we needed to identify and eliminate. The script consisted of thousands of lines of code with hundreds of different functions and function calls. I needed to know where the majority of the execution time was being spent. Examining each individual function was impractical, if not impossible, so I turned to tick functions, which are a quick and cheap alternative to a real profiler. Another lesser known PHP function that was recently added to the API is debug_backtrace(). This function returns an array consisting of the current call stack. It returns the location from which the current function was called and the location from which that previous call was made, all the way back to the main script. Calling debug_backtrace() inside of a tick function returns the location where PHP broke execution to call the tick function. This information can be used to determine the current function being executed. Repeatedly calling this function provides a rough estimate of the time spent in every function. Take a look at Listing 3. The tick function is called Profiler(). It accepts one parameter, the default being false. debug_backtrace() provides the name of the function currently be executed. The function name is given in the “function” element. The “class” and “type” elements are used in case the function is a member of a class. The elapsed time is added to $functions with the function name as the key. Finally, we keep a running total in the ~TOTAL~ element of $functions. This allows us to compare the execution times to the total time. If a true value is passed into the first parameter, the previous code is skipped and the {$functions} array is returned. This section of the code, along with register_tick_function() and declare, should be placed at the top of the main script. Doing so causes Profiler() to track the time spent in each function. In our sample script, we just run three simple little functions then print out the results. You’ll notice that the
13
FEATURE
Uncovering how PHP “Ticks”
majority of the time is spent in sleep5(), whereas only a trivial amount of time is spent in loop100(). The value of the ticks directive in declare will determine the accuracy. The higher the value, the less frequent the ticks, so the more likely you will be to have function calls start and finish between ticks, thus never being tracked. At the same time, the lower the ticks directive, the longer the script will take to run due to the additional overhead. In my project, I was able to locate one function in which more time was spent than any other. We rewrote the function as a PHP extension and were able to shave up to a second off of our execution times. Pitfalls and Caveats While tick functions can be a very powerful tool, they can also be a bit temperamental. There are a number of caveats and pitfalls of which being aware may save you quite a bit of headache. The most important thing to remember while working with tick functions is that they are not threads. While tick functions are similar to threads, they are two very distinct things. PHP still maintains a linear execution model even when using tick functions. Rather than having two or more processes running at the same time using the same data, tick functions act as if you were to manually insert a particular function call every few lines. Although tick functions break the execution of the main script, the latter only continues once all tick functions return. Also, once a tick function begins, all ticks are suppressed. Thus we avoid the danger of a stack overflow from nested tick calls. This means that many of the hassles of threads (semaphores, synchronization) are avoided. At the same time, many of the benefits are lost as well. The next pitfall to be aware of is the utilization of the declare construct. As stated before, it is not a function. It bears more resemblance to preprocessor directives in C or C++, since it functions independently of the PHP syntax. The ticks characteristic is applied to the very lines of code rather than setting a variable in the command flow. Therefore, once a block of code is given a certain ticks value with the declare construct, that block of code will always exhibit that characteristic even if called from a location where another declare was called. declare constructs also disregard flow control statements. A declare is always executed once it is reached in the code, even if contained within an unexecuted conditional block. For example, look at Listing 4. To exhibit the effect of declare, we have a tick function that prints an asterisk. Three different examples are presented, each of which prints ten dots in a row. We can see the effect of the declare by the number of dots that appear for each asterisk. Notice that no asterisks appear in the first line of dots
December 2004
●
PHP Architect
●
www.phparch.com
because the ticks value is not currently set. We then call wait(), which is contained in a declare block and thus generates ticks at a rate of two. Finally, we have an if statement that always resolves to false. Nevertheless, the declare still takes effect, causing the final for loop to be broken up by ticks. Because of how awkward declare can be, it’s generally best to select a tick frequency, set it at the top of the first script and not worry about it again. If you need to stop ticks from begin generated, unregister all of the tick functions. Trying to meddle with declare will only cause you to lose your temper. At least, that’s what it does to me. Another thing to be aware of is that tick functions are slow, especially if you set the ticks frequency to a low value or have a large callback function. Remember that this function will be inserted every N statements. If the ticks frequency is one and the tick function is ten lines long, you can safely assume that your script will slow substantially. Be sure to be aware of the effect on system resources, and set the ticks frequency accordingly. Finally, keep in mind that tick functions can be a bit unreliable at times. The only time I ever remember causing a segmentation fault in PHP that didn’t involve building an extension has been while using tick functions. There is also a rumor that Apache in Windows is not very fond of ticks, though I have been unable to verify this claim. I do know it works fine in Apache on Linux. Just be aware that there are some risks involved. Wrapping it all Up Tick functions are one of those interesting things that you never see a need for until you know how to use them. Tick functions provide a completely different paradigm and, as such, you are bound to see many ways to employ them to your benefit. The following are a few varied uses I have found for tick functions above and beyond those listed previously: a full-featured debugger (with variable watching, breakpoints, and so on), an event-handling system, a multithreaded MySQL query engine, and a function call monitor. The possibilities are nearly endless, so good luck and keep on ticking.
About the Author
?>
Michael Paul Bailey (
[email protected]), a Mathematics student at Brigham Young University, works as a fulltime software engineer for Omniture (http://www.omniture.com). He spends his evenings performing improv with ComedySportz (http://www.comedysportzutah.com). He maintains a web site with tutorials, random code snippets, and his rantings at http://www.jinxidoru.com.
To Discuss this article:
http://forums.phparch.com/187 14
FEATURE
F E A T U R E
Powerful Solutions to Common Problems
Design Patterns by Devon Weller
Many common programming problems have already been solved. A design pattern is a formal explanation of a solution to a type of problem; design patterns are well-tested, elegant solutions that can turn good code into great code.
S
ome programming problems are more common than others. In fact, some problems are so common that we, as programmers, find ourselves facing them again and again. These regular problems are similar enough to each other that we recognize them, but just different enough that no past solution will work exactly. Just like we begin to recognize similar problems, we also recognize similar solutions. Over time, we find that some solutions work well and others do not. We keep the good solutions in our repertoire and send the bad ones back to the ether, from whence they came. If a good solution has an identifiable purpose and plan of attack, we can call that solution a design pattern. Design Patterns So, what exactly is a design pattern? Simply put, design patterns are elegant, proven solutions to common problems. A pattern is not a specific programming technique. Programming techniques include subclassing objects and using global variables. A design pattern is more general than this. It is a big-picture approach to solving a general problem. Think of design patterns as the collected wisdom of many programmers solving a similar problem many times. Studying and using design patterns can help a good programmer grow into a great programmer. To help
you on your quest to learning design patterns, we will examine the building blocks of a design pattern. We will then look at three commonly used design patterns and use them to solve specific problems with PHP code. These patterns are named Singleton, Composite and Strategy. Header and Footer: An Example Pattern You probably already use design patterns in your programming, even though you may not realize it. If you repeatedly use a similar approach to solve similar problems, then you are using a design pattern. One common pattern in PHP programming is sharing a header and footer on every page of an application. To illustrate how a design pattern works, we will formalize a definition of this simple design pattern. The first thing we need is a name. We’ll call it the Header and Footer pattern. At the very minimum, the definition of a pattern contains a name, a brief statement of the purpose of this pattern, a description of the solution, and a list of the
REQUIREMENTS PHP: 4.x/5.x OS: Any Other Software: None
Code Directory: Patterns December 2004
●
PHP Architect
●
www.phparch.com
16
FEATURE
Design Patterns: Powerful Solutions to Common Problems
pros and cons to this solution. A complete definition will also include an in-depth explanation including sample code. A formal definition of our Header and Footer could look like this: Name: Header and Footer Intent: Share common header and footer code across multiple pages of an application Description: Often, web-based applications share common code at the top and bottom of many different pages. It is possible to use the same code on many separate pages of our application, with each file containing an exact copy of the code. A better solution is to share this code by including a separate file at the beginning and ending of each page. By using these separate header and footer files, we can share the same code across multiple pages. This allows more flexibility and promotes code re-use. Benefits: Because we share the same code, we can make a change to one file and that change will be reflected on all pages that use this code. Liabilities: Sometimes, you do not want the same code on the header or footer of every page. In this case, the Header and Footer pattern may not be appropriate for your design. Implementation Including a header file in PHP is a simple matter of using an include “header.php” statement at the beginning of each page of our application. Similarly, an include “footer.php” statement at the end of each page will include the footer. While the Header and Footer pattern is simplistic, it does illustrate the definition of a design pattern. Now that we have defined this pattern formally, we can make reference to it as a single concept: Header and Footer. This allows us to mention it by name both in our documentation, code comments and even in our mind. Next, we will look at three commonly used design patterns. These are useful patterns that solve more complex problems. They were originally presented in the book Design Patterns: Elements of Reusable ObjectOriented Software by Gamma, Helm, Johnson, and Vlissides. I will present my interpretation of these patterns and how they apply specifically to solving problems encountered in web programming with PHP.
December 2004
●
PHP Architect
●
www.phparch.com
The Singleton A Singleton is an object that can have only one instance across your entire code. The Singleton pattern ensures that only one instance of a class exists. Think of a Singleton like a super global; as you know, there is only one instance of the $_GET super variable in your code. When using a Singleton, we want to emulate this same type of behavior: we want there to be one, and only one, instance of our Singleton object used by the rest of the code. I will illustrate the use of a Singleton by presenting a database caching problem that we need to solve. In our example, we have rows of users stored in a database, each with a unique ID number. We wish to be able to access this data from anywhere in our code quickly and simply. However, for performance reasons, we do not want to send duplicate queries to the database to request the same information. Our example will solve this problem by caching this Listing 1 1
17
FEATURE
Design Patterns: Powerful Solutions to Common Problems
data in memory once it has been retrieved from the database. We will create a class to store the data called ObjectStore. For the caching to work properly, there can be only one instance of ObjectStore in existence at any given time. To ensure there is only one, we will employ the Singleton design pattern. Listing 1 shows the implementation of ObjectStore in PHP. Note that $the_object_store = new ObjectStore() will not work. Clients must use ObjectStore by $the_object_store = &object_store::getInstance() . The getInstance() method is the heart of our Singleton implementation. This function creates the one instance of $object_store_singleton if it doesn’t exist already. It then returns a reference to this instance. The first call will create and return the ObjectStore Singleton, while future calls will continue to return a reference to the same ObjectStore. We have implemented a safety feature to keep someone (usually ourselves) from attempting to create a new ObjectStore without using our getInstance() method. We added the trigger_error() command in the constructor to throw an error if a new instance is created with someone using the code $the_object_store = new ObjectStore(). If, at a later point in our development, we forget to use the getInstance() method, the ensuing fatal error will certainly jog our memory. Listing 2 implements the same solution in PHP5. Here you can see that the evolved object-oriented nature of PHP5 allows us to implement a simpler solution. By naming the constructor as a private function, PHP will throw an error when code outside of the ObjectStore class attempts to create a new ObjectStore. Singletons can be effectively used in web applications programming. Some good uses that I have found for them in my own code include classes that represent a database interface, an authenticated administrative user, and a class that represents the current page of a multiple page application. In my own experience, I
have found that the Singleton pattern requires a small investment in programming time to implement, but pays big dividends in elegance and encapsulation.
“ Think of design patterns as the collected wisdom of many programmers solving a similar problem many times.”
Composite Our next candidate is called the Composite Design Pattern. You can use a Composite when you have both single items and groups of items that contain single items. A Composite design lets you treat the groups of items in the exact same way as the single items. In other words, the class representing single items has the same functions as the class representing groups of items. At first this may seem unintuitive. Why would you want to treat single items the same way as groups of items? It turns out that having the same interface for single items and groups of items can simplify and better organize your code. The internal code of your Composite classes takes care of the difference and handles the singles and groups differently. The code outside of your Composite classes, however, is much simpler because it does not need to distinguish whether it is dealing with a group or a single item.
Figure 1 !"#$%&'()*+(
!%&'()*+($)6-(
!%&'()*+($+,%-
.>,?(18;1",+(%. 898@9;5
./*0121",+(%.
!%&'()*+($)6-(
!%&'()*+($)6-(
8989;5
!%&'()*+($)6-(
●
PHP Architect
892:9;5
!%&'()*+($)6-(
89
