Thoughts, rants and commentary of a simple man

Creating a custom XML logger for SugarCRM 7

Posted on October 8th, 2014 in Programming,Web Development,Work | No Comments »

I recently ran across a question on StackOverflow in which the original poster asked about creating a custom XML logger for SugarCRM. He was wondering where to put his custom class and some of the particulars surrounding this so I thought I’d pitch in and help out.

I created my own custom XML logger class – SugarXMLLogger – and saved it at custom/include/SugarLogger/SugarXMLLogger.php. I then applied it to the Ping API for testing both as a replacement for fatal level logging and as a replacement for the default logger. Since the functionality of the logger is intended to be simple, I didn’t feel the need to extend SugarLogger. However, I did feel it at least appropriate to implement LoggerTemplate so that the integrity of the logger among the stack of loggers was kept in tact. If you want the fullness of SugarLogger in your custom loggers then you should extend SugarLogger. However, for a simple XML logger that wasn’t absolutely necessary.

As far as the log is concerned, I kept all the same information as is normally in sugarcrm.log with the only change being how it is stored. Since XML is structured it made sense to structure the logged information accordingly. So, without further ado, here is the code for the SugarXMLLogger…

The SugarXMLLogger Class

<?php
/** 
 * Save to custom/include/SugarLogger/SugarXMLLogger.php
 * 
 * Usage: 
 * To make one particular log level write to the XML log do this:
 * ```php
 * <?php
 * LoggerManager::setLogger('fatal', 'SugarXMLLogger');
 * $GLOBALS['log']->fatal('Testing out the XML logger');
 * ```
 * 
 * To make all levels log to the XML log, do this
 * ```php
 * <?php
 * LoggerManager::setLogger('default', 'SugarXMLLogger');
 * $GLOBALS['log']->warn('Testing out the XML logger');
 * ```
 */
 
/**
 * Get the interface that this logger should implement
 */
require_once 'include/SugarLogger/LoggerTemplate.php';
 
/**
 * SugarXMLLogger - A very simple logger that will save log entries into an XML
 * log file
 */
class SugarXMLLogger implements LoggerTemplate
{
    /**
     * The name of the log file
     * 
     * @var string
     */
    protected $logfile = 'sugarcrm.log.xml';
 
    /**
     * The format for the timestamp entry of the log
     * 
     * @var string
     */
    protected $dateFormat = '%c';
 
    /**
     * The current SimpleXMLElement logger resource
     * 
     * @var SimpleXMLElement
     */
    protected $currentData;
 
    /**
     * Logs an entry to the XML log
     * 
     * @param string $level The log level being logged
     * @param array $message The message to log
     * @return boolean True if the log was saved
     */
    public function log($level, $message)
    {
        // Get the current log XML
        $this->setCurrentLog();
 
        // Append to it
        $this->appendToLog($level, $message);
 
        // Save it
        return $this->saveLog();
    }
 
    /**
     * Saves the log file
     * 
     * @return boolean True if the save was successful
     */
    protected function saveLog()
    {
        $write = $this->currentData->asXML();
        return sugar_file_put_contents_atomic($this->logfile, $write);
    }
 
    /**
     * Sets the SimpleXMLElement log object
     * 
     * If there is an existing log, it will consume it. Otherwise it will create
     * a SimpleXMLElement object from a default construct.
     */
    protected function setCurrentLog()
    {
        if (file_exists($this->logfile)) {
            $this->currentData = simplexml_load_file($this->logfile);
        } else {
            sugar_touch($this->logfile);
            $this->currentData = simplexml_load_string("<?xml version='1.0' standalone='yes'?><entries></entries>");
        }
    }
 
    /**
     * Adds an entry of level $level to the log, with message $message
     * 
     * @param string $level The log level being logged
     * @param array $message The message to log
     */
    protected function appendToLog($level, $message)
    {
        // Set some basics needed for every entry, starting with the current
        // user id
        $userID = $this->getUserID();
 
        // Get the process id
        $pid = getmypid();
 
        // Get the message to log
        $message = $this->getMessage($message);
 
        // Set the timestamp
        $timestamp = strftime($this->dateFormat);
 
        // Add it to the data now
        $newEntry = $this->currentData->addChild('entry');
        $newEntry->addChild('timestamp', $timestamp);
        $newEntry->addChild('pid', $pid);
        $newEntry->addChild('userid', $userID);
        $newEntry->addChild('level', $level);
        $newEntry->addChild('message', $message);
    }
 
    /**
     * Gets the user id for the current user, or '-none-' if the current user ID
     * is not attainable
     * 
     * @return string The ID of the current user
     */
    protected function getUserID()
    {
        if (!empty($GLOBALS['current_user']->id)) {
            return $GLOBALS['current_user']->id;
        } 
 
        return '-none-';
    }
 
    /**
     * Gets the message in a loggable format
     * 
     * @param mixed $message The message to log, as a string or an array
     * @return string The message to log, as a string
     */
    protected function getMessage($message)
    {
        if (is_array($message) && count($message) == 1) {
            $message = array_shift($message);
        }
 
        // change to a human-readable array output if it's any other array
        if (is_array($message)) {
            $message = print_r($message,true);
        }
 
        return $message;
    }
}

The structure of the log

<?xml version="1.0" standalone="yes"?>
<entries>
    <entry>
        <timestamp>Wed Oct  8 11:56:04 2014</timestamp>
        <pid>89160</pid>
        <userid>1</userid>
        <level>fatal</level>
        <message>Testing out the XML logger</message>
    </entry>
</entries>

How to log only fatal logs to the XML log

<?php
LoggerManager::setLogger('fatal', 'SugarXMLLogger');
$GLOBALS['log']->fatal('Testing out the XML logger');
?>

How to log all logs to the XML log

<?php
LoggerManager::setLogger('default', 'SugarXMLLogger');
$GLOBALS['log']->warn('Testing out the XML logger');
Back to top

Storing singleton objects in PHP sessions

Posted on March 14th, 2012 in Geek Stuff,PHP,Programming,Web Development | 1 Comment »

A friend of mine, who is working on a sick little diet and exercise tracking application, asked me today if PHP allowed singleton objects to be stored in a session. My first reaction was absolutely they can be so long as you follow the normal rules of unserializing objects in PHP… namely, making sure the class is in scope before attempting to create an object from it OR having an autoloader that does that for you. But as I thought about it more I began to think that maybe this might not work as expected since singletons generally have no public access to their constructors. However, when an object is unserialized, it is instantiated, for lack of a better term, and populated with the data that was exposed from the serialization process.

Note: for those of you that are unfamiliar with the way PHP handles session data or are just wondering why I am using serialization so much in my examples, the basics are you start a session and PHP assigns a random MD5 hash to it as an id. You write data to the session via the $_SESSION superglobal array and when the script terminates or you call session_write_close(), PHP serializes the $_SESSION array and writes that serialized string to the file system for retrieval on subsequent requests so long as the session time limit has not expired. I really did not want to run this entire session process and inspect what was being written to my file system so I decided to mock that interaction myself by creating an arbitrary array, serializing it, grabbing the serialized string and unserializing it.

As I began to dig into this I started playing with PHP’s magic __sleep() and __wakeup() methods. Those seemed to do what I wanted them to do except in the case of protected and private properties of my class. As soon as I added those in my serialization took a crap all over itself, even when I cloned the singleton object and got the public properties exposed through get_object_vars(). So, thanks to the PHP manual – the most awesome tool in any PHP developer’s arsenal – I discovered the PHP Serializable interface.

This interface defines two methods: serialize() and unserialize(). These methods override the default behavior of __destruct() and __construct() so if you are using these you should keep that in mind and either put your __destruct() and __construct() code into these methods or allow for calls to __destruct() and __construct() from within these methods. Your homework is to decide which is the better implementation. 🙂

Now, back to the lesson at hand… the following object – let’s say it is saved to a file named dummy.php – is a super simple implementation of a basic singleton pattern. It includes both a serialize() and unserialize() method to allow it to be serialized for storage.

<?php
class DummySingleton implements Serializable {
    /**
     * Test properties of various visibility
     * @var string
     */
    public $dProp;
    public $dPropX = 'Nothing to see here folks';
    private $_prop = 'y u try see dis?';
 
    /**
     * Instance holder for this singleton
     * 
     * @var DummySingleton
     */
    private static $_instance = null;
 
    /**
     * Private singleton constructor, simply sets a property
     */
    final private function __construct() {
        $this->dProp = 'I was finally built';
    }
 
    /**
     * Singleton instance getter
     * 
     * @return DummySingleton
     */
    public static function getInstance() {
        if (self::$_instance === null) {
            self::$_instance = new DummySingleton();
        }
 
        return self::$_instance;
    }
 
    /**
     * Implementation of the Serializable interface, called automatically just 
     * before this object is serialized. This will override any calls to a
     * __destruct method, so if you have a destructor you should call it from
     * here.
     * 
     * @return string
     */
    public function serialize() {
        return serialize(get_object_vars($this));
    }
 
    /**
     * When this object is created from an unserialization this method is called. 
     * It implements the Serializable interface and uses the data from the 
     * serialize() method herein. Since this method overrides the __construct
     * method you should make any accomodations for constructing your object
     * in this method.
     */
    public function unserialize($data) {
        // "Instantiate" our singleton
        self::getInstance();
 
        // Set our values
        if (is_array($data)) {
            foreach ($data as $k => $v) {
                $this->$k = $v;
            }
        }
    }
}
?>

If you build up this object then serialize it, then rebuild it from the serialization, you can see that it remains in tact. Let’s test this by simulating the session array, first creating an array then adding the DummySingleton object to that array, then serializing it:

<?php
// Grab the class
include 'dummy.php';
 
// Get our instance
$o = DummySingleton::getInstance();
 
// Set something into it for testing
$o->setFromOutside = 'What the hell is this madness?';
 
// Make an array of stuff
$a = array();
$a['name'] = 'Robert';
$a['id'] = 23;
 
// Add the singleton
$a['dummy'] = $o;
 
// Serialize it
$s = serialize($a);
?>

The serialized output from this yields:

a:3:{s:4:"name";s:6:"Robert";s:2:"id";i:23;s:5:"dummy";C:14:"DummySingleton":187:{a:4:{s:5:"dProp";s:19:"I was finally built";s:6:"dPropX";s:25:"Nothing to see here folks";s:5:"_prop";s:16:"y u try see dis?";s:14:"setFromOutside";s:30:"What the hell is this madness?";}}}

If you take that string and subsequently load it and unserialize it then inspect it, you’ll see that the singleton object has been restored along with all private properties of it:

<?php
// $s is our serialized string from above
$o = unserialize($s);
var_dump($o);
?>

Output:

array(3) {
  ["name"]=>
  string(6) "Robert"
  ["id"]=>
  int(23)
  ["dummy"]=>
  object(DummySingleton)#1 (3) {
    ["dProp"]=>
    NULL
    ["dPropX"]=>
    string(25) "Nothing to see here folks"
    ["_prop":"DummySingleton":private]=>
    string(16) "y u try see dis?"
  }
}

Since this is, in essence, the process that PHP follows for its default session management it’s safe to say that you can, indeed, store singleton objects in a PHP session. Now onto to bigger and better questions, like…

Why would you ever want to store a singleton object instance in a PHP session?

Back to top

Javascript, WebKit and ‘closed’

Posted on February 26th, 2012 in Javascript,Programming,Web Development | 2 Comments »

The other day I was playing around with a simple letter scrambler script that I had written to assist my daughter with a birthday party game. The concept is simple enough… enter a phrase, hit a button and the phrase gets “cryptoquoted”, a process where each letter in the phrase is substituted with another letter. One of the things I designed this program to do was hide the input box so that, if you were viewing it on the web, the solution would not be visible to anyone looking at the puzzle. But I also programmed it so that if you click a link, the input box would be revealed. This toggling of the visibility of the input box is simple enough to do. Just add a little jQuery and BAM!, you have a simple revealer.

And this is exactly how this performed until the last time I tried it a couple of days ago. My toggler suddenly stopped working right, but only in Chrome and Safari. All of the javascript was firing in the proper order, and the function I had written was being called but my slider was not sliding. After digging into this a little bit, and doing a bit of debugging, I found out that a variable name I was using the monitor the state of the visibility of the input box was being clobbered in Chrome and Safari. Firefox worked just fine as it always has. The variable name I was using was closed.

// Set the closed flag
var closed = true;
 
/**
 * Toggles visibility of the input box
 */
function toggleSolution() {
	if (closed) {
		closed = false;
		$('#puzzle-key').slideDown();
		$(this).text('Hide solution');
	} else {
		closed = true;
		$('#puzzle-key').slideUp();
		$(this).text('Show solution');
	}
}

When inspecting this code in Chrome Developer Tools, regardless of any actions, events or any other browser interaction, the closed variable always was valued as false. I still don’t know why this is happening, but I do know this is a WebKit issue. And I also know that changing the variable name from closed to _closed solved the issue I was having. Also, as a simple test, without declaring the variable anywhere in my code, I opened up the console on a page without any javascipt at all and, sure enough, the variable was set to the value false.

So if you writing javascript and run across an issue where you are using a variable named closed in your code that always seems to be valued at false, be aware this might be an issue with your browser and simply changing the name of your variable in your code might make things all better for you.

Back to top

Simple PHP table maker

Posted on November 28th, 2011 in PHP,Programming,Web Development | No Comments »

A little while ago I was in need of a way to take tab separated data sets and make HTML tables out of them cleanly. Mostly this was from data copied from a spreadsheet, but sometimes copying from web pages or even text documents has brought this need up for me. So in keeping with my mantra of “Why not write a program to do that?” I decided to write a simple HTML table maker that will take in tab separated, structured data and return an HTML table from it, complete with column headings, a caption and a summary (sidenote: I know that table summaries are being deprecated… still, I included it because at the moment they are still in use for pre-HTML5 markup).

So without further ado, I bring you my simple HTML table maker. It isn’t the most robust thing in the world, but it is still pretty neat. Plus? It totally serves my purpose to the tee. So if you don’t like it, why not gank the code for it and make it better?

Back to top

Simple PHP Class generator

Posted on May 20th, 2011 in PHP,Programming,Web Development | No Comments »

Someone on the Professional PHP Group asked the question yesterday about whether Dreamweaver has a utility to write setters and getters to your PHP classes for you. I know that ZendStudio has this feature and I am pretty sure that NetBeans has it as well.

But as I thought about this, I thought “How cool would it be to be able to take a list of PHP properties and build a class out of that list complete with your getters and setters?”. That’s when my inner nerd took over and I created a very simple PHP Class Generator.

It is not the most robust tool in the world, but if you are looking for a quick way to build out a class of getters and setters from a simple list of variables, this little tool might be right up your alley. I’d encourage you to play with it and see if it can help you. If it does, tell me about it in the comments.

Oh yeah, a major thank you goes out to Jason Memory of Full Throttle Web Solutions for his help and wizardry in all things regex.

Back to top

Newest title: Book reviewer

Posted on October 23rd, 2009 in Personal Messages,PHP,Web Development | No Comments »

A few days ago I received an email from Packt Publishing, “a UK based publishing firm specializing in focused IT books” asking if I would be willing to review a new book they are publishing entitled Zend Framework 1.8 Web Application Development. The book, written by Keith Pope, appears to cover the basics of using the Zend Framework to build web applications rapidly.

According the book description:

The Zend Framework has a flexible architecture that lets you build modern web applications and web services easily. The MVC components make the maintenance and testing of your applications easier. However, it is not only an MVC framework for developers. It also provides an easy-to-use high-quality component library that is designed to be used the way you want, picking up specific components without requiring the use of whole framework.

It’s easy to get started and produce a powerful and professional looking web site when you’ve got this book to hand. Taking you through a real-life application, it covers the major Zend Framework components, as well as throwing light on the best practices and design issues faced when building complex MVC applications.

This book takes you through detailed examples as well as covering the foundations you will need to get the most out of the Zend Framework. From humble beginnings you will progress through the book and slowly build upon what you have learned previously. By the end, you should have a good understanding of the Zend Framework, its components, and the issues involved in implementing a Zend Framework based application.

I am actually looking forward to reading what Keith has put together. With some of the more recent improvements to the Zend Framework I have been really considering putting the framework to use in a project. Hopefully having examples to follow will point me in the proper direction.

Regardless, I am looking forward to reading what Keith has to say about developing with the Zend Framework. And if nothing else, at least I get a free chapter of a new PHP book out of the deal. 😉

Back to top

ZendCon 2009: Day 3

Posted on October 22nd, 2009 in Geek Stuff,PHP,Programming,Web Development | 1 Comment »

And so ends the Zend PHP Developers Conference for 2009…

The last day of ZendCon is always a mixed bag when it comes to wrapping things up. On the one hand you, as a programmer, are loving the learning and education and networking and mixing things up with your peers. But on the other hand you, as a regular person, are tired from all the learning and education and networking and mixing things up with your peers (and drinking… and eating… and more drinking). Still, when all is said and done, all good things must come to an end. And so it goes with ZendCon.

Today started out pretty much the same as the other days except we knew we were in for a half day of sessions instead of a whole day. With that we chose the sessions we wanted to attend and headed for our rooms.

Session 0: Design Patterns for PHP developers
This was the second talk of Cal’s that I attended this ZendCon and, much like the first, Cal gave a great presentation on Design Patterns for PHP. Covering the basics of design patterns, he made sure to mention the most important patterns we could use, like Factory, Strategy, Observer, Model-View-Controller, Facade and Singleton. He made the samples very easy to understand and was quick to answer the questions asked of him.

Design Patterns have a special place in my heart as a programmer (I have given talks to local meetup groups about design patterns) and I love how knowing design patterns levels out the disparity between programming languages. Knowing them makes one language for all programmers and allows anyone from any language background to be able to communicate programming concepts and paradigms in a common tongue, if you will. That said, Cal delivered big-time in his talk on patterns. He also inspired me to pursue my ambition of putting together a PHP Design Patterns web site for developers that have not seen, or do not understand, design patterns applied to PHP.

Slide for Cal’s presentation can be downloaded here. (.pdf)

Session 1: Authorization with OAuth
Rob Richards gave a talk about OAuth and the difference between authentication and authorization. He moved pretty quickly into an actual implementation of using OAuth for authentication of a user from an application and, in my opinion, moved a little too fast into too concrete of an implementation. Still, the presentation was very informative and useful for anyone that is thinking of utilizing OAuth as an authentication mechanism.

Day 3 && ZendCon wrap-up
I was a little saddened to see the end of the conference come up so fast. Still, I am glad its over because I can use the rest.

I’m thinking next year I want to see if I can get in on giving a talk. I’d love to present and would love to not have to pay to get into the conference 🙂 . I also think that it would be freaking awesome to have a small group of the guys I have met over the last two hears at ZendCon over to my home for a BBQ or something, though I should probably bring that up with my wife before I even think of doing anything like that (I will honey, I promise 😛 ).

Overall, this year’s conference was better than last years in a couple of ways. First, the subject of many of the talks was NOT scaling. That, in and of itself, made this conference better than last year.

Second, the location was also a bit better than last year, being closer to downtown and all that being in downtown has to offer.

On the other hand, this year’s conference was deficient in several area. First off, the lack of power in the lobby and in the conference rooms was painful. Having a laptop battery with only a 38% capacity made it difficult to attend a session that didn’t have sufficient power.

Secondly, the vendor fair this year kinda sucked. It was nice to have them there, as always, but they didn’t seem to want to interact with people this year. The shirts were awesome and the shwag was also very nice -who doesn’t like free, right? Still, I think having more relevant vendors with more accessibility to relevant and pertinent information would have been nice.

Regardless, I got nothing but love for the organizers of this conference. Specifically, kudos need to go out to Eli White (@eliw) for his incredible support of the conference and attendees, and Keith Casey (@CaseySoftware) for the indescribable work he does on the conference uncon sessions. I cannot wait for ZendCon2010.

Back to top

ZendCon 2009: Day 2

Posted on October 21st, 2009 in Geek Stuff,PHP,Programming,Web Development | No Comments »

Yesterday was an amazing day at ZendCon. Lots of talks, lots of information, lots of networking, lots of geekdom. The day was long but very informative and at the end of it I couldn’t wait to get back for today.

Today started off a bit different than yesterday because today I was scheduled to take the Zend Framework Certification exam and my coworker was scheduled to take the Zend Certification Exam. So we got to the conference and camped out for the morning to get some last minute studying in.

As we studied we were joined by Aaron Wormus. I’m not sure why, but when presenters and other people who are widely known in PHP are close by I always feel like I am in the presence of a celebrity. Last year I was like a little kid at a football game, meeting everyone, shaking hands, being excited, enjoying the conference. This year? Well, kinda the same, except I haven’t seen to have as much time this year to find people to meet.

Still, it was nice to be able to spend a couple of hours trying to familiarize myself with the Zend Framework. The exam preparation study guide is 214 pages long, and as of 12:15, when it was lunch time, I had gotten through about 110 page of it. So much for being totally prepared for the exam.

After lunch was over my coworker and I headed to the exam room where we took our test. And wouldn’t you know it… I passed. So now I am not only a Zend Certified PHP Engineer, I am also Zend Framework certified as well. Sweet!

After the certifications were over we were able to get back into the swing of the sessions…

MySQL Server Performance Tuning 101
Cal Evans, filling in for Legaya Turmelle, did an excellent job of describing how to optimize your MySQL server and sent queries to enhance the performance of your applications. Filled with an incredible amount of technical data, this presentation was still a vibrant session that involved the attendees throughout the entire session. And I managed to sneak away two things that will be a help to me as soon as I get back to work:

/* Show all of your global variables */
mysql > SHOW GLOBAL VARIABLES;
 
/* Show your statuses */
mysql > SHOW GLOBAL STATUS;

Both of these can filter your queries by adding a “LIKE ‘%{filter}%'” to the query. Very handy pieces of information.

Architecting Your Models
Matthew Weier O’Phinney gave an awesome talk about architecting models (the M in MVC) and using your models to handle business logic. The logic that was employed was very similar to the Introduction to Zend Framework talk he gave on Monday (kudos for consistency) and covered data access, table/row gateways and service layers.

This is one of those presentations that I would recommend you get the slides for because just the programming practices employed in his presentation make it an absolutely stellar session and one that can only help you as a programmer. [Note: as soon as the links to the slides are posted I will put that link here. Sorry.]

Building Desktop RIAs with JavaScript and PHP
Ed Finkler gave a sweet presentation on taking PHP and Javascript from the web to the desktop in his talk on building Rich Internet Applications. His talk was dynamic, funny, had a couple of well handled snafus and totally captivated the audience.

Using Adobe AIR, Appcelerator’s Titanium and PHP, he built a couple of cool little desktop apps that are driven by server hosted PHP applications. Though the apps were just for example, what you can do with AIR or Titanium, jQuery and PHP is freaking amazing and I can’t wait to try some of this stuff when I get back to work.

Links to his presentation and associated code samples:

Day 2 wrap-up
Sitting here, at the end of the last session, I am overwhelmed with the amount of information I learned in the last couple of days. I am so looking forward to how ZendCon will be wrapping up tomorrow and cannot wait to meet some of the people of I haven’t yet had a chance to meet.

Back to top

ZendCon 2009: Day 1

Posted on October 20th, 2009 in Geek Stuff,PHP,Web Development | Comments Off on ZendCon 2009: Day 1

The second day of ZendCon is always a busy day. That is the day the sessions start; when you try as hard as you can to be in three places at once; where you spend half of each session reading Twitter for all #zendcon hash tags or hang out on the #zendcon IRC channel; when all you can think of outside of PHP is free swag and free beer.

Today was like that for me. Well, minus the mad rush to sit in on the morning keynote. I spent the early morning reading up on the Zend Framework so I can stand a chance at passing the ZF Certification Exam tomorrow. There is a lot to learn in that stupid manual (214 pages long – gripes!) so there was naturally lots of reading to do. After that we started the day.

Session 0: PHP 5.3 = Awesome
Ilia Alshanetsky gave this talk on PHP 5.3 and some of the new and exciting features in it. Outside the fact that Ilia never stops talking… I mean never… this talk was filled with some pretty cool stuff that a lot of programmers have been waiting for in PHP.

He opened with talking about namespaces and how they can be used. There are so many ways to utilize the namespace feature that to repeat that here would take a lot of screen real estate. I would recommend getting your hands on the slides of the presentation and reading through the first few slides. There is lots of useful information on namespaces in the slides.

The next thing he talked about was the new usage for the ternary operator. While there are, I’m sure, different ways to implement this feature, the manner in which it is implemented right now is pretty neat. Essentially you can now say “If the first condition evaluates to true, use it, otherwise use the second” without saying it exactly that way:

<?php
// We used to do this with ternary
$var = $a ? $a : $b;
 
// Now we can do this
$var = $a ?: $b;
?>

That is pretty slick in my opinion.

There was also mention of the use, internally, of the MySQLInd client library for MySQL Database Server interaction and how much overhead is being saved on select queries when not manipulating SELECT query result set data. Essentially you can cut your memory consumption in half because of this change. Sweet.

After this the talk moved into some new stuff you can do with INI files and data you can set in them. This change will make configuration pretty freaking sweet in my opinion, just because of what you can set and how you can set it. There is also some pretty nifty stuff that is happening with the DataTime built in objects in PHP. And lastly, there is a new PHP constant being introduced. That constant is E_DEPRECATED and it will be used to tell you, when you have error_reporting set to E_ALL, if what you are using in PHP 5.3 is slated for deprecation in PHP 6.

Overall this was an awesome talk. Ilia is a great speaker, knows his stuff very well and packs in about three hours worth of presentation into about an hour.

Session 1: Xdebug — PHP developer’s swiss-army knife
Presented by Derick Rethans, the author of xDebug, this presentation covered an enormous set of the features included in xDebug. Derick also talked about kcachegrind and utilizing xDebug with PHPUnit to cover many aspects of unit testing and debugging

Slides for Derick’s talk are available for download at his website.

Session 2: Mastering OpenXML Documents with PHP
Aaron Wormus gave an excellent talk about the PHPExcel library and how it utilizes the OpenXML standard to write complex and feature rich spreadsheets for Microsoft Excel, Open Office and other text based formats. This was very well presented session and covered several different, clearly coded examples.

Session 3: Premature Optimization Mistakes
Another awesome presentation by Ilia Alshanetsky, this session talked about some of the wrong directions programmers can go into when trying to optimize their applications. Many myths were debunked in this session, like the idea that smaller code is better code, removing comments in PHP makes your applications faster and changing your code makes it better. I even installed APC on the PHP Developer’s Network forums during this presentation to buy some performance gain without having to do any really heaving lifting.

Again, Ilia put about three hours worth of information into an hour long session and knocked it out of the park.

Session 4: Taming the Deployment Beast
Chris Cornutt, the man behind PHPDeveloper.org and joind.in, gave a hugely informative presentation about deployment and managing your applications from the start of development to the implementation of production over both teams of developers and for individual programmers.

Covering an array of various tools, practices and principles, Chris’s presentation was filled with application lifecycle management concepts, deployment practices and low level programming practices.

Slides can be downloaded here

Day 1 wrap-up
Much like last year, the first day of ZendCon was packed with information, networking, free swag (thank God for vendor fairs) and great food. Seriously%2

Back to top

ZendCon 2009: Day 0

Posted on October 19th, 2009 in Geek Stuff,PHP,Web Development | No Comments »

Woo to the frickin’ hoo! ZendCon 2009 is back in town!

I am fortunate enough to work for a company that believes that you should continue your education within your professional field. They back up that commitment by putting their money where their mouth is and actually spending money to send their employees to various training seminars and conferences throughout the year. And this year, like last year, ZendCon is that conference for me.

Like last year, this year opened up with the conference tutorials day. This year I chose to focus on Zend Framework and learning what I could of it. It is a fast growing framework and is quickly becoming a popular tool in the arsenal of many a PHP developer. I am seeing more and more recruiter emails that are asking for ZF experience. And it is a beast of a code base, well written and extremely well organized, developed by a team of people that are some of the biggest and brightest names in PHP development around the world.

Session 0
My day started out with an Introduction to Zend Framework by Matthew Weier O’Phinney. Matthew gave a stellar presentation on using the Zend Framework to develop a pastebin application. Covering some of the ins and outs of the MVC architecture employed by the Zend Framework, he also taught some programming practices as he started out first by developing his models, then his forms, then his controllers then his views. He taught techniques like setting view variables as their lowest PHP variable type so they are not to tightly coupled to a particular implementation should controllers or models change (like passing a result array to the view as opposed to a DB result object).

He also went into a decent amount of detail on Zend_Tool, Zend_Config, plugins and routing. In the end I felt like I could actually do something cool with the Zend Framework. Maybe not as cool as what he did, but cool nonetheless.

Now if I could just figure out those sweet vim plugins he was using…

Session 1
Seeing as the Zend Framework certification exam is being offered to conference attendees for free I figured since I am here that I would try to add to my ZCE certification. To do that I figured I’d sit in on the Zend Framework Certification Refresher course being presented by Rob Allen.

I am pretty sure I was in over my head from the start of this class. One of the first things that Rob said was that this class was not a tutorial on Zend Framework but a refresher for those that are using it regularly. For almost every component that was covered he asked the question “Who has used this?” and sadly I could not raise my hand for hardly any of them. Still, on the practice questions I did alright because much of the Zend Framework is common enough that you can expect certain behavior from it. That seemed to get me some pretty good mileage.

Of course there were lots of things that I had never seen, either. Parts of Zend_Log (and the writers, the formatters and the filters), parts of Zend_Db (the table data gateway and the row data gateway), Zend_Auth (the returns from Zend_Auth::authenticate()) and a host of other items from the framework are fodder for me reading up on.

Still, I think I can pass the exam if I don’t overthink the questions being asked. Of course, that means lots and lots of reading tonight, tomorrow, tomorrow evening and Wednesday morning.

Other happenings (and mishappenings)
When my coworker and I got to the conference and registered that we were there we noticed something missing from our registration packet. All early registrants who attended a previous ZendCon were supposed to receive a netbook for the conference. Ours was not there. Throughout the day we checked back in with the front desk, per their instruction, and found out at the end of the day that we would be getting ours tomorrow. That was a small bummer, though it had a happy ending so I am pretty stoked about that.

Something else I noticed this year was the lack of power in the rooms. Last year there was no shortage of power plugs to plug my laptop into. This year, in the first session, only the people that sat next to the walls close to an outlet could plug in. The second session was a little better in that my room had two power strips. Still, both of those were on one side of the room so if you sat on the other side of the room for the three hour session there was a decent chance that you were going to be running out of power before the end of the session.

Wireless internet this year was way better than last year for me (albeit a lot slower). Connecting to it was a snap and once I was able to power up my laptop I was able to stay connected to the internet pretty much the entire rest of the day.

Lunch was really good this year. For a boxed lunch the food was really, really good. As were the dining accommodations. My coworker and I were able to meet some new folks (a fellow from Seattle, John from Vermont and another fellow from Slovenia) as we talked about the ZCE, differences between PHP and Java and this year’s conference versus last year’s.

Ending the day this year was a little sad for me. Not because the day was over and I had to wait an entire half a day to mingle with my peers again. No, it was because of the $18 I spent on parking at the Convention Center. What. The. Hell? There was no validation either. And to top it off, the stupid ticket reader didn’t work so we had to drive around the entire garage until we found a guy that could help us.

Still, given the day as it went, I am very happy with ZendCon this year. I cannot wait until it gets into full swing tomorrow. And I really can’t wait for some of the uncons that were just posted late tonight.

Back to top