There it is in the PHP manual for return():

Note: since return() is a language construct and not a function, the parentheses surrounding its arguments are not required. It is common to leave them out, and you actually should do so as PHP has less work to do in this case.

I knew the parentheses were optional, but I’ve been merrily using them all along. And I probably would have continued doing so until I saw the second note attached to the docs:

Note: You should never use parentheses around your return variable when returning by reference, as this will not work. You can only return variables by reference, not the result of a statement. If you use return ($a); then you’re not returning a variable, but the result of the expression ($a) (which is, of course, the value of $a).

I’ve been using __FILE__ for years, but I never thought to look for its siblings.

echo ' line:'. __LINE__ .' file:'. __FILE__ .' directory:'. __DIR__ .' function:'. __FUNCTION__ .' class:'. __CLASS__ .' method:'. __METHOD__ .' namespace:'. __NAMESPACE__;

I feel as though I should have noticed these earlier; they’re clearly referenced in the docs for debug_backtrace(), after all.

This two year old post about Rasmus Lerdorf’s PHP scaling tips (slides) is interesting in the context of what we’ve learned since then. APC now seems common, and it’s supposedly built-in to PHP6. Still, I’d be interested in seeing an update. Are MySQL prepared statements still slow?

And that’s where Rasmus’ latest presentation comes in. We don’t learn anything about MySQL prepared statements, but we do learn how to find choke points in our applications using callgrind and other tools. In his examples, he can do a little over 600 transactions per second with both static HTML and simple PHP, but various frameworks — with many inclusions and function calls — can slow that to under 50 transactions per second (I suppose they’d explain that in a TPS report).

1. Yum up some packages:

   yum install php-pear php-devel httpd-devel

2. Install APC using pear (the pear installer is smarter than the pecl installer):
   When the installer asks about APXS, say ‘no’. 

   pear install pecl/apc

3. Tell PHP to load APC:

   echo extension=apc.so > /etc/php.d/apc.ini

4. Restart Apache:

   /sbin/service httpd graceful

I’ve been pretty aware of the risks of SQL injection and am militant about keeping my database interactions clean. Mark Jaquith today reminded me about the need to make sure my browser output is filtered through clean_url(), sanitize_url(), and attribute_escape(). Furthermore, we all need to remember current_user_can(), check_admin_referer(), and nonces.

I’ve got a PHP script that sometimes just dies with no errors to the browser and no messages in the error log. I’ve seen this in the past with scripts that consumed too much memory (yeah, it should have issued an error, but it didn’t, and increasing the memory limit fixed it), but now the memory limit is set pretty high and I’m not sure I want to increase it further. I certainly don’t want to increase it without seeing where it’s going wrong, anyway.

To do that, IBM developerWorks says the memory_get_usage() and memory_get_peak_usage() functions are for me. And they offer some other interesting tips as well.

David Cloutman pointed to Craiglist’s job ads as an indicator of programming language popularity. Here’s the hit counts for “web design jobs” and “internet engineering jobs” in the Bay Area:

Cloutman has a few ideas for what the numbers mean, but I’m just entertained by the data. (Note: he corrected his original numbers.)

Stuck with PHP 5.1.6 on RHEL or even CentOS (and a sysadmin who insists on using packages)? Need JSON? I did. The solution is easy:

yum install php-devel
pecl install json

The pecl install failed when it hit an 8MB memory limit, and I was clueless about how to fix it until I learned that the pecl installer ignores the php.ini. Turns out the best solution is to use the pear installer (which does follow php.ini settings):

pear install pecl/json

I spoke of this the other day, but now I’ve learned of PHP’s DOM functions, including loadHTML(). Use it in combination with simplexml_import_dom like this:

$dom = new domDocument;
$dom->loadHTML('<ul><li>one</li><li>two</li><li>three<ul><li>sublist item</li></ul></li></ul>');
if($dom){
	$xml = simplexml_import_dom($dom);
	print_r($xml);
}

This IBM developerWorks article has some more useful info.

Here’s some code I prototyped to parse out the ISBNs and LCCN (or any data, really) from an an average record in Scriblio:

$dom = new domDocument;
$dom->loadHTML($content);
if($dom){
	$xml = simplexml_import_dom($dom);
}
foreach($xml->body->ul->li as $thing){
	if($thing['class'] == 'isbn'){
		foreach($thing->ul->li as $stuff){
			print_r($stuff);
		}
	}
	if($thing['class'] == 'lccn'){
		foreach($thing->ul->li as $stuff){
			print_r($stuff);
		}
	}
}

I love how easily I can traverse an HTML document with jQuery, and I’d love to be able to do it in PHP. There are a few classes, but the PHP binding for Tidy seems to be where it’s at. The Zend dev pages make it look that way, anyway.

p0ps Harlow tweeted something about trying to get an AMP environment running on his Mac. Conversation followed, and eventually I sent along an email that look sorta like this:

If you’re running 10.4 (I doubt it, but it’s worth mentioning because I’m most familiar with it), here’s how I’ve setup dozens of machines for web development and WordPress:

Install MySQL
http://dev.mysql.com/downloads/mysql/5.0.html#macosx-dmg

Install Marc Liyanage’s PHP 5 package
http://www.entropy.ch/software/macosx/php/

From there all you have to do is install WordPress.

10.5 changed lots of this (as you probably already know). The good news is that it includes current versions of the AMP suite. The bad news is that the PHP doesn’t include a number of useful components. Still, it will run WordPress and I’ve got it working on my laptop. These directions look like pretty much what I had to do:

http://stringfoo.com/2007/11/05/server_setup_on_leopard/
http://remysharp.com/2007/10/27/lamp-in-leopard-osx-105-php5-and-apache-22

It’s likely none of that will be helpful, in which case you will have discovered why I’m no longer a sysadmin.

Marc Liyanage’s builds of PHP for Mac are probably the easiest to use and they include most all the extensions a person could want, but he hadn’t released a package for Leopard at the time (he’s got a release in beta now). As it turned out, p0ps actually was running 10.4, and he got things going in a jiffy.

sifting results of

error_log( $_SERVER['REQUEST_URI'] ."\n". $_SERVER['REMOTE_ADDR'] ."\n". print_r( debug_backtrace(), TRUE ) );

Yep. Leopard comes with new stuff. Lazeez says it works fine, but commenters here are having trouble.

leopard, Mac OS X 10.5, apache, php

I’ve been working on MySQL optimization for a while, and though there’s still more to done on that front, I’ve gotten to the point where the the cumulative query times make up less than half of the page generation time.

So I’m optimizing code when the solution is obvious (and I hope to rope Zach into giving the code a performance audit soon), but I’m also looking at optimizing how PHP works.

Once upon a time, most of us ran PHP as a CGI, and every time a request came in, the PHP interpreter would have to launch, read/compile/execute the script, then spit out the result and shutdown. Now (hopefully) everybody’s running PHP as an Apache module, so all the time spent launching the interpreter, allocating memory and other resources for it, and then shutting it down and cleaning up after it, is done just once for each thread of Apache.

It might not sound like much, but I had a chance to compare CGI vs. module performance recently and found that a fairly simple, but frequently accessed script running as a CGI completely swamped a server as a CGI (creating a load average over 20), but was hardly noticed when running as a module.

But even as a module, the PHP scripts still need to be interpreted and compiled before they can be executed. And because of the way PHP works, this is done every time the page/script is requested.

Java programmers, among others, criticize PHP for this, but that small inefficiency is part of what makes PHP so easy to use (and popular). And that ease of use means people are building some really interesting apps worth scaling.

Anyway, there’s a solution to eliminate that inefficiency in PHP: intermediate code caching.

By caching the executable code generated by the interpreter, then the using the cached copy instead of the source script for the next request, you can enjoy the benefits of PHP’s easy development and compiled code’s fast execution time. A number of projects all promise anywhere from double to 10X jump in performance.

• ionCube PHP Accelerator
  This has the most recognizable “brand,” and some hosting providers even offer it, but it’s offered only in binary form and the license seems intentionally ambiguous (um, not free?).
• Turck MMCache for PHP
  Has a good performance chart, and is GPL’d, but development appears to have ended in 2003.
• afterBURNERr*Cache
  Yeah, I had to point to a page in the Wayback Machine, this project is dead.
• Zend Platform Performance Suite
  A commercial suite that includes piles of goodies, if you pay.
• APC: Alternative PHP Cache
  It’s under active development and includes Rasmus Lerdorf, the guy who created PHP, among the project leads. License: BSD-style (non-copyleft)

I haven’t actually tried any of these yet, but I’m looking for information and suggestions, and I’m likely to try APC, maybe even Zend soon. Just as soon as I make an app compelling enough (and large enough) to need it.

php, caching, acceleration, zend, apc, intermediate code cache, optimization, scaling, web applications

Daniel Lemire and Sean McGrath note that “User personalization and profiling is key to many succesful Web sites. Consider that there is considerable free content on the Web, but comparatively few tools to help us organize or mine such content for specific purposes.” And they’ve written a paper and released prototype code on collaborative filtering.

Vogoo claims to be a “a powerful collaborative filtering engine that allows Webmasters to easily add personalization features to their Web Sites.”

Item-based Collaborative Filtering, Recommender Systems, e-Commerce, Collaborative Filtering, code libraries, php, web application development

I expected a record that looked like this:

LEADER 00000nas  2200000Ia 4500
001    18971047
008    890105c19079999mau u p       0uuua0eng
010    07023955 /rev
040    DLC|cAUG
049    PSMM
050    F41.5|b.A64
090    F41.5|b.A64
110 2  Appalachian Mountain Club
245 14 The A.M.C. White Mountain guide  ba guide to trails in
       the mountains of New Hampshire and adjacent parts of Maine
246 13 AMC White Mountain guide
246 13 White Mountain guide
246 13 A.M.C. White Mountain guide
260    Boston,|bThe Club,
300    v.  bill., maps (some fold., some col.) ;|c16 cm
362 0  1st-     ed.; 1907-
500    Title varies slightly
651  0 White Mountains (N.H. and Me.)|xGuidebooks

but instead got a record that looked like this:

00939cas  2200265Ia 4500001001300000003000700013005001700020008004100037020001500078040001800093050001600111110003100127245012200158246003000280246002600310246003200336246003000368260005500398300005700453362003600510500002700546650001100573651007300584999001600657
ocm18971047
OCoLC
20020918102844.0
890105c19079999mau u p       0   a0eng
  a0910146489
  aDLCcAUGdNHS
  aF41.5b.A64
2 aAppalachian Mountain Club.
14aThe A. M. C. White Mountain guide :ba guide to trails in the mountains of New Hampshire and adjacent parts of Maine.
13aAMC White Mountain guide.
13aWhite Mountain guide.
13aA.M.C. White Mountain guide
13aAMC White Mountain guide.
  aBoston, Mass. :bAppalachian Mountain Club,c1983.
  a550 p.bill., maps (some fold., some col.) ;c16 cm.
0 a1st- ed.; 1907- ; 25th ed. 1992
  aTitle varies slightly.
  aHiking
0aWhite Mountains (N.H. and Me.)xDescription and travelxGuide-books.
  aCL000018321

(some of the non-printable characters have been replaced with newlines for readability.)

After staring at that record for entirely too long, forgetting about it for a while, then returning again to think about how unreadable it was, then forgetting about it again, then taking one last look, I had that *duh* moment that made me realize what I should have seen on first glance: this is a MARC record that hasn’t had its directory parsed.

So here’s my short-but-handy-and-hopefully-usefull-to-somebody-sometime code to parse the directory and then the rest of the record. It assumes $records is an array of records.

foreach($records as $record){
	$temp = explode('', $record);
	$dir = $temp[0];
	$record = substr($record, (strlen($dir) + 1));

	$dir = substr($dir, 24);
	$dir_field = NULL;
	while($dir){
		$dir_field[] = substr($dir, 0, 12);
		$dir = substr($dir, 12);
	}

	$record = str_replace('', '|', $record);
	$marc = NULL;
	foreach($dir_field as $field){
		if(ereg_replace('[^0-9]', '', $field)){
			unset($temp);
			$len = substr($field, 3, 4);
			$pos = substr($field, 7, 5);
			$field = substr($field, 0, 3);
			$temp = substr($record, $pos, $len);
			if($field < 10)
				$temp = '  |'. $temp;
			$marc .= trim($field .'|'. $temp) .“\n”;
			$marc_array[$field] = $temp;
		}
	}
	echo $marc;
}

The actual output of that code on that record is this:

001|  |ocm18971047
003|  |OCoLC
005|  |20020918102844.0
008|  |890105c19079999mau u p       0   a0eng
020|  |a0910146489
040|  |aDLC|cAUG|dNHS
050|  |aF41.5|b.A64
110|2 |aAppalachian Mountain Club.
245|14|aThe A. M. C. White Mountain guide  ba guide to trails in the mountains of New Hampshire and adjacent parts of Maine.
246|13|aAMC White Mountain guide.
246|13|aWhite Mountain guide.
246|13|aA.M.C. White Mountain guide
246|13|aAMC White Mountain guide.
260|  |aBoston, Mass.  bAppalachian Mountain Club,|c1983.
300|  |a550 p.|bill., maps (some fold., some col.) ;|c16 cm.
362|0 |a1st- ed.; 1907- ; 25th ed. 1992
500|  |aTitle varies slightly.
650|  |aHiking
651| 0|aWhite Mountains (N.H. and Me.)|xDescription and travel|xGuide-books.
999|  |aCL000018321

It includes a little bit of fudging that my other MARC parsing code demands, but works and is readable.

code, libraries, library, marc, marc directory, parsing, php, raw marc

I needed a quick, perhaps even sloppy way to output an array as XML. Some Googling turned up a few tools, including Simon Willison’s XmlWriter, Johnny Brochard’s Array 2 XML, Roger Veciana Associative array to XML, and Gijs van Tulder’s Array to XML. Finally, Gijs also pointed me to the XML_Serializer PEAR Package.

In an example of how even the smallest barriers can turn people away, I completely ignored the two possible solutions at PHP Classes, because navigating and using the site sucks. I passed on Willison’s function because, well, it didn’t look like it would do enough of what I wanted. Despite Gijs’ recommendation of the PEAR module, I was happy enough to use his array_to_xml function, as it did what I needed and required the lest work for the moment. I may revisit XML_Serializer sometime, but…

array, array to xml, php, xml, XML_Serializer

• memcached, a “highly effective caching daemon, …designed to decrease database load in dynamic web applications,” and the related PHP functions
• pspell PHP functions related to aspell and this pspell overview from Zend
• http_build_query, duh?
• current connected mysql threads * unix load average = system busy; reduce operations when $system_busy > $x

development, memcached, mysql, php, pspell

Somewhere in the WordPress code extra slashes are being added to my query terms.

I’ve turned GPC magic quotes off via a php_value magic_quotes_gpc 0 directive in the .htaccess file (we have far too much legacy code that nobody wants to touch to turn it off site-wide). And I know my code is doing one run of addslashes(), but where are the other two sets of slashes coming from?

addslashes, gpc magic quotes, php, wordpress, wpopac

My Sun T2000 is here, and with Cliff’s help it’s now patched, configured, and online. (Aside: what’s a Sun Happy Meal?)

I’ll second Jon’s assessment that Sun really should put some reasonable cable adapters in the box, as the the bundle of adapters necessary to make a null modem connection to the box is ridiculously out of scale (I’ll get a picture soon).

I’m getting the application environment put together, which has turned out easier than expected thanks to the convenient packages from Blastwave.org. The box came with Solaris 10 installed, and after a quick installation and configuration of pkg-get I was happily installing Apache, MySQL, and PHP as simply as typing pkg-get -i apache.

AMP, AMPS, Apache, Blastwave.org, LAMP, MySQL, PHP, Solaris, Solaris 10, Sun, Sun Microsystems, T2000

A Solaris sysadmin I’m not. But now that I’ve finally got the Sun T2000 server I begged for a while back, I’ve got to ramp it up right quick.

The first task is to get a, um, LAMP environment up and running (SAMP?…oh, Sun wants us to call it AMPS). A bit of Googling turned up this forum thread that suggested Blastwave.org’s ports of PHP, MySQL, and Apache.

edit: I corrected the model number.

amp, amps, apache, lamp, mysql, open source, oss, php, solaris, sun, t2000

I didn’t hear big announcement of it, but deep in the docs (? PHP 5.1.0) you’ll find a note about additional Libxml parameters. In there you’ll learn about “LIBXML_NOCDATA,” and it works like this:

simplexml_load_string($xmlraw, 'SimpleXMLElement', LIBXML_NOCDATA);

Without that option (and with all previous versions of PHP/SimpleXML), SimpleXML just ignores any < ![CDATA[...]]> ‘escaped’ content, such as you’ll find in most every blog feed.

cdata, cdata in php, fixed, parsing rss, php, php5, rss, simplexml, xml

A couple notes from the past few days of tweaks and fixes:

• Hyper-threading has a huge effect on LAMP performance.
   
• From now on, I’ll have bad dreams about running MySQL without Query Caching in the way that I used to have nightmares about going to school wearing only my underwear. The difference is that big.
   
• WordPress rocks, but it has some queries that will kill large databases. I’m playing with baseline when I fix ‘em, but it’s worth it.
   
• Being highly ranked for searches related to bears and bear lovers on the weekend that Grizzly Man airs on TV is both good and bad: it doubled my previous high for daily page-loads, but killed my server and taught me some lessons about sloppy coding.
   
• The support techs are Lunarpages continue to pretty much rock.
   
• Having friends who cut their teeth on high-performance PHP/MySQL and are willing to spend the night workshopping it with you is indispensable.
   
• It’s hard to beat the calming beauty of driving home through a snowfall on back roads at 2 AM carried by your life’s soundtrack.
   

lamp, mysql, php, server optimization, mysql optimization, server performance, hyperthreading, performance optimization

Everybody likes documentation. The Zend folks posted this overview and SimpleXML introduction The O’Reilly folks at ONLamp offered this guide to using SimpleXML. Of course, there’s always the SimpleXML docs at PHP.net.

Two problems: I haven’t encountered CDATA in my XML yet, but I do hope to develop a better solution than offered here when I do. The other is that SimpleXML chokes on illegal characters, a unfortunately common occurrence in documents coming from III’s XML Server.

tags: cdata, docs, documentation, php, php5, simplexml, xml server, xml

Or, er, my server will be crushed. I guess I should admit that my stuff could do with some optimization, maybe. Perhaps what I really need is something faster than Celeron with 512MB RAM. Maybe.

tags: 512mb ram, apache, break point, breaking point, celeron, crushed, load average, mysql, php, server, top, web server