Jim Plush's Programming Paradise

Super Secret Invites are going out!

Thu, 10 Dec 2009 04:09:32 UTC

Exciting times at the new job. We're releasing a handful of super secret invites to the new site. Crazy days to come. Wish I could say more at this time.

Farewell Panasonic

Fri, 13 Nov 2009 21:07:07 UTC

After 5+ years at Panasonic I've decided to accept a new position with Blue Rover Labs. It will be an exciting change back to start up life and I'm looking forward to getting started. I bought a Civic Hybrid with carpool stickers this morning so I'm all set for the commute :)

It was a pleasure to work with everyone at Panasonic. They really do take care of their employees and that really made the decision difficult.

We'll see what happens in the future!

If Zend Form was a girl I'd marry it

Fri, 31 Jul 2009 16:49:40 UTC

So a few months ago I took the leap and spent some time getting down and dirty with Zend_Form. The elements, decorators, display sub groups, validations, filtering, etc...
In our new project we are now creating a single form class and are able to use that for our edit form, creation form and also a method for "read only" that will just display the contents properly all using the same form code. We have custom validators plugging into the elements. It's just a beautiful thing. Once you get the hang of it whipping out quality forms is a snap.

Nice job Framework devs

I'll be speaking at ZendCon 2009

Thu, 30 Jul 2009 04:53:31 UTC

I'm currently set to speak at ZendCon 2009 on the topic of "How to run an enterprise PHP Shop" (http://zendcon.com/)

I'd love to see what people may be most interested in talking about. I've be a lead developer at McAfee and Panasonic, two large, very different corporations.

Here's what my blurb on the Zend site says:

"How to run an enterprise PHP Shop

Speaker: Jim Plush

In this session we'll take a look at how to successfully manage and lead PHP teams. We'll cover finding and interviewing PHP developers, the processes involved with producing products (build, qa, release, continuous integration, and development processes), building the team, team standards (coding, documentation, unit testing, reviews), providing ongoing education, and preventing developer burn out. We will also touch on the balacing act between process and productivity.

22.10.2009 | 09:15 bis 10:15 Uhr "

I'm currently working on the outline for the talk. It's only an hour and I have a lot to cover so if there's anything you want me to focus on just drop me a comment. Here is my super rough outline so far:

How to find, interview and hire PHP developers
How to manage teams
Coding Standards
Testing standards
Build Processes
Release Processes
Bug reporting and mitigation processes (bug scrub meetings with steering team)
Requirements gathering
Deploying Code
Training the team
Unit Testing
Continuous Integration Servers
System Testing
Weekly team meetings
Pre-release Bug Parties, prizes for most show stoppers, most bugs found
Tools we use at Panasonic (svn, why not to use telelogic change, phing, phpunit, zend framework, twiki wiki)
Team Building
Importance of certifications
Importance of the balance between process and performance
Wikis for collaboration
Why we chose Zend Framework

Rethinking Zend Models Part 4 - Create new user

Wed, 22 Jul 2009 20:43:27 UTC

I've gone ahead and added the createuserAction to my indexController to illustrate how we could reuse all the code previously written to validate and save creating a new user. If you want to view the change log to see the code I added to support this, you can view it here: http://code.google.com/p/plushcode/source/detail?r=23

Here's what our createuserAction code looks like now

 
 public function createuserAction()
    {
    	// we're going to be creating a user
    	$userRepo = new user_UserRepository();
    	$user = $userRepo->getNewUser();
    	
    	// pass the form the validator it needs to work with
    	$form = new forms_CreateUserForm(array('Validator' => new user_validation_Default($user)));
    	
 
		// find a user with id 1 in the DB
    	if ($this->getRequest()->isPost()) {
	            if($form->isValid($_POST)) {
	   
	    		$values = $form->getValues();
 
		        // let's update the user's email address to what was posted from the form
		        $user->setEmailAddress($values['email']);
		        
		        // update the profile's nickname
		        $user->Profile->setNickname($values['nickname']);
        
		        
		    	// check to make sure the whole user object is valid with these new changes
		        if(!$user->isValid()) {
		        	$this->view->errors = $user->getMessages();
		        } else {
		        	$userRepo->save($user);
		        	$this->view->message = "USER CREATED!";
		        }
	    	}
    	
        }
    	
    	$this->view->form = $form;
    	
    }

Rethinking Zend Models Part 3 - Validation

Tue, 21 Jul 2009 22:03:12 UTC

I've gone ahead and added validation to our test project: http://code.google.com/p/plushcode/source/browse/#svn/trunk/ZendModel/application/default/models
If you take a look at the indexController you'll now see I've added an updateAction that uses a Zend Form component.

The goal of the validation was to provide context sensitive validation on a model. A model by itself might not know if it's valid or not so you'll want to apply different contexts depending on what the client operation is. Saving an order might have a different validation need than shipping an order. Instead of hacking a bunch of if/else statements you can simple say

 
$order->setValidator(new order_validation_NewOrder());
 
// OR
 
$order->setValidator(new order_validation_ShipOrder());
 
if(!$order->isValid()) {
    $messages = $order->getMessages();
}

and $order->isValid() will operate on that context object. The form object get's pass a validator so it can also operate on the same validator chains as the model so you don't have to duplicate that logic.

Anyway, I think it can be improved so take a look!
If you've downloaded and installed the code you'll be able to find the example on your local machine: http://youraddress/index/update

Followup on rethinking Zend Models with DDD - Framework code included

Fri, 17 Jul 2009 00:59:14 UTC

As a follow up to my previous post I'm going to post some live examples of model layer with Zend framework based on Domain Driven Design concepts. I've spent the past few days studying up on domain driven design as well as a lot of Martin Fowler's work in relation to domain modeling and I think I have at least some code to start with that could get some conversations rolling. The issue is Zend Framework doesn't have a formal model layer and it shouldn't. Models are very much domain specific to what you're working on. As I've mentioned in my previous post sometimes you need complex business logic that will need to rapidly change and adapt to growing business needs. Active record can only get you so far when complexity expands.

I've posted a working Zend Framework project that has a basic working set of models so far. The current concept has a User who in turn owns a profile object. That profile object holds a nickname attribute that we can play around with. I have two tables users and profiles that are joined with a foreign key (user_id). Normally when you want profile information you'd just do a join and work with the result. What if that profile becomes context sensitive? What if a user can have a different profile based on the location he's in? Maybe he's a CIA agent and if he's overseas he needs a different profile to be covert. You'd now have to start adding conditions to your logic to account for this. Having the user own a profile object that can be injected at runtime allows for these contexts to be more manageable.

What if your user is going to be used in a workflow engine, a piece of marketing business logic that operates on users, it will be nice to be able to pass around a complete User object that has well documented properties and APIs instead of forcing each business logic service to know the details of your database.

Here is the google code repository you can checkout and play around with: Google Code Repository for Zend Model project
It's all working, just create a database and dump in the zendmodel_DB.sql file, change your config.ini file settings and you're all set assuming you handle your apache settings

Take a look at the default/controllers/IndexController.php file for how the client code will be used.

 
	// instantiate the user repository who will be in charge of building a proper user
        $userRepo = new user_UserRepository();
        
        // find a user with id 1 in the DB and grab their current nickname from the profile
        $user = $userRepo->find(1);
        $this->view->nickname = $user->Profile->getNickname();
        
		// set their nickname in their profile to something new
        $user->Profile->setNickname('tommy tom');
        
        // find the user again, it should pull the same object reference and not create a brand new object (Identity Map)
        $user = $userRepo->find(1);
        $this->view->nickname2 = $user->Profile->getNickname(); 
        
      
        
        // a fictional web service to check to see how popular your new nickname is
        $profileService = new services_ProfileService();
        $popularity = $profileService->howCommonIsMyNickname($user);
        $this->view->popularity = $popularity;
        
        
        // let's update the user's email address
        $user->setEmailAddress('newdude@yahoo.com');
        
        
        // you can manually commit the save to the database like this or in the destruct method of ObjectManager 
        // it will do it automatically for you, this will save all the changes we've made to all our objects
        // using the unit of work pattern in ObjectManager, the profile and the user will get updated
        ObjectManager::performOperations();

We have a User model and we have some supporting files around it.
in models/user/ you'll see some files:
/User.php
/UserMapper.php
/UserRepository.php

Each one plays a role within the domain User.php is the model itself that models a user in our system. It contains no SQL or knowledge of the persistence layer and can be passed around to any app on ths system. UserMapper.php is our basic DB Mapper that is in charge of doing the dirty work of putting things into our database. UserRepository is the default User Factory for creating a valid User object along with it's dependencies. Because this could be context sensitive we can contain that logic in a central place in there or add another Repository.

if you look in models/infrastructure/ObjectManager.php you'll see this file is a combination identity map and unit of work. It's job is to make sure if we have already instantiated a User object for example that we get back the same exact one and don't try to recreate it. It's basically an object cache.

Anyway, take a look and let's talk about what's right and what's wrong and how we can improve the complex domain model with Zend Framework. I'd like to start building on this example with everyday issues like logging, authentication, transactions, validation, unit tests, etc...

Rethinking the Zend Models

Tue, 14 Jul 2009 20:06:34 UTC

I'm currently in requirements mode for an upcoming project that should prove to be pretty complex. The current active record/table gateway patterns just aren't going to cut it for the complex business logic that's approaching. I'm starting to lean towards the domain model approach which would increase the initial complexity of the design but allow for the flexibility for future changes and features. The issue is with where to put your business logic? Most of the rails and Zend framework examples show a more active record type pattern which means that the business logic is tied into the persistence storage layer.

For example...
$user = new User();
$user->salary = 100;
$user->updatePayroll();
$user->save();

This works well for smaller apps where your models are tied tightly to your database structure however in my case I'll need to add the application layer above an existing database structure that may have 5 tables per object. For the example above I've diagrammed a possible solution

In this example I've created a User and Company class. Each one holds it's own data and basic operations. There is no sql in these, no direct knowledge of the outside world. Each model has a corresponding Mapper class (data mapper pattern) that knows how to save, find, create and delete it's own model. On top of those layers will sit a service layer that handles the real business logic. The UserPayrollService deals specifically with managing payroll for a user. UserAuthService is strictly for authenticating and logging out a user. As more and more complexity is added such as the need to have a User as part of a workflow engine I can simply create a new service or modify an existing one to implement the new business logic. Some additional benefits are that you can show the diagrams to your stakeholders and they can see concrete evidence that you've captured their business requirements as well as having the components testable on an individual level.

here are some examples of how it could be used...

 
/**
* high level use case for an immediate login and update of salary
*/
 
$userAuth = new UserAuthService();
 
if($user = $userAuth->authorize($_request['email'], $_request['password'])) {
	$payroll = new UserPayrollService($user);
	$payroll->updateSalary(100000);
	$currentPay = $user->getSalary();
	// currentPay would now equal 100000
} else {
	// auth fail
}

 
/**
* example of creating a new user
*/
$userMapper = new UserMapper();
if(!$userMapper->userExists($_request['email'])) {
	$user = new User();
	$user->email = $_request['email'];
	$user->firstName = $_request['firstName']
	$user->lastName = $_request['lastName']
	$userMapper->save($user);
	redirect('/home');
} else {
	// user already exists
}

Anyone have any thoughts on this implementation? What has served you well?

I believe I'm a MySQL Certified Developer Now

Tue, 09 Jun 2009 00:05:40 UTC

I just passed the 2nd test over the weekend for the MySQL developer certification. It was definitely harder than the Zend Certified developer test. There is no way I could have passed without some serious studying. The test covered tons of topics such as Client/Server Concepts, Joins,The mysql Client Program,,Subqueries,Connectors ,Views,Data Types ,Importing and Exporting Data,Identifiers,User Variables,Databases,Prepared Statements,Tables and Indexes,Stored Routines,Querying for Data,Triggers,SQL expressions,Obtaining Database Metadata,Updating Data,Debugging MySQL Applications,Basic Optimizations.

It's a two part, 70 questions per part test. I would definitely suggest getting the study guide as well as reading the online manual.

The Right MySQL Engine for High Capacity Servers

Thu, 23 Apr 2009 04:39:55 UTC

As you may know there are many storage engines in MySQL MyISAM, InnoDB, Falcon, CSV, Blackhole, Archive, etc...There is a storage engine that comes with the MySQL Max Download called the "Blackhole Engine". According to the documentation it basically dumps it's storage to /dev/null. A storage engine that doesn't store anything? What good could that be?

Well if you run in a high volume production system where you may have one or more master databases for writes/updates/deletes and a whole farm of slaves reading the log from that master than this may be of interest to you. The concept is pretty simple. You have a Master database that is in charge of all your inserts, deletes, updates which in turn has connections to all those slaves. That means network traffic, disk I/O, CPU power all taking up resources that you really want for the Master's primary goal of collecting and maintaining data.

This is where the Blackhole Engine comes in. The actual process of logging the SQL statements that hit the Master database that the slaves consume lives above the storage engine level in the main MySQL server level. So with the Blackhole Engine piping data to /dev/null you can actually use it as a proxy to your slaved databases without the need to duplicate the data on that machine (it could very well be on the same machine!). See below for an example image...

What you then have is the Master only replicating to one database, increasing the Master's capacity to process transactions. The slaves consume the log file from the Blackhole server. It acts as a proxy at this point, with the benefit of freeing up resources on the Master's server. This could also benefit multi continent replication set ups where you can have farms of blackhole servers farming data to farms of slaves around the global for faster local access times. The possibilities are endless!