So far the proposed topics cover everything from iPhone development to "Design for Developers" to .NET to PHP, Ruby, Coworking, and anything else under the sun.

So if you're around the area this Friday, show up and join in the fun! Just make sure to RSVP in the wiki linked above (the password/invite key is "c4mp") or the Facebook event.

The solution seemed to be that the router hated TCP Window Scaling. The fix that so far seems to work is to edit your /etc/sysctl.conf file and adding the line:

net.ipv4.tcp_window_scaling=0

And then running the command:

sudo sysctl -p

To reload the changes.

While there already exists a Python set of classes that serializes (and serializes) Python data, it (a) didn't handle objects and (b) was licensed under the GPL (rant to follow later), meaning I couldn't use it for it's intended purpose due to the closed source nature of my project.

I decided this was a good enough time to play around with git so I created a github repo here.

It could probably still use some more TLC in the object area, maybe a few more supported types, and unserialization functions would be nice.

I do feel it wasn't bad for a few hours of hacking if I do say so myself.

The code for the module (should be in a phpserialize.py file) is as follows:

Python Code

"""
Collection of functions to serialize Python variables to the native PHP format
 
@version 0.1
@author Daniel Cousineau <dcousineau@gmail.com>
@copyright Copyright (c) 2008 Daniel Cousineau
@license http://www.opensource.org/licenses/mit-license.php MIT License
"""
 
from types import *
 
def serialize(var):
	"""
	Serialize var to the native PHP serialization format
	"""
	if type(var) is IntType or type(var) is LongType:
		return serialize_int(var)
 
	elif type(var) is FloatType:
		return serialize_decimal(var)
 
	elif type(var) is BooleanType:
		return serialize_boolean(var)
 
	elif type(var) is StringType:
		return serialize_string(var)
 
	elif type(var) is NoneType:
		return serialize_null()
 
	elif type(var) is ListType or type(var) is TupleType:
		return serialize_array(var)
 
	elif type(var) is DictType:
		return serialize_dictionary(var)
 
	elif type(var) is InstanceType:
		return serialize_object(var)
 
	else:
		raise TypeError("Invalid Type %s" % (type(var)))
 
def serialize_string(string):
	"""
	Format: s:L:"STRING";
		L: Length of the string
		STRING: The string itself. No need to escape quotes (")
	"""
	return "s:%d:\"%s\";" % (len(string), string)
 
def serialize_int(int):
	"""
	Format: i:D;
		D: the integer
	"""
	return "i:%d;" % (int)
 
def serialize_decimal(decimal):
	"""
	Format: d:D;
		D: the decimal (accepts expontent notation)
	"""
	return "d:%s;" % (decimal)
 
def serialize_boolean(boolean):
	"""
	Format: b:B;
		B: 1 for True, 0 for False
	"""
	return "b:%d;" % (boolean)
 
def serialize_null():
	"""
	Format: N;
	"""
	return "N;"
 
def serialize_array(array):
	"""
	Format: a:K:{VALUES}
		K: Number of entries (number of keys for dictionaries)
		VALUES: serialized key appended to serialized value. Do not worry about ;
		        if a value is an array
 
	DOES NOT END WITH A ;
	"""
	values = []
	for index, value in enumerate(array):
		values.append(serialize_array_key(index))
		values.append(serialize(value))
	return "a:%d:{%s}" % (len(array), "".join(values))
 
def serialize_array_key(var):
	"""
	Decimals and Boolans are automatically converted to integers for key values.
	Arrays and Objects throw errors if they are set as a key
	"""
	if type(var) is IntType or type(var) is FloatType or type(var) is BooleanType:
		return serialize_int(int(var))
 
	elif type(var) is NoneType:
		return serialize_int(0)
 
	elif type(var) is StringType:
		return serialize_string(var)
 
	else:
		raise TypeError("Invalid Key Type %s" % (type(var)))
 
def serialize_dictionary(array):
	"""
	See serialize_array()
	"""
	values = []
	for index, value in array.iteritems():
		values.append(serialize_array_key(index))
		values.append(serialize(value))
	return "a:%d:{%s}" % (len(array), "".join(values))
 
def serialize_object(obj):
	"""
	Format: O:L:"CLASS":K:{MEMBERS}
		L: Length of class name
		CLASS: class name (string)
		K: Number of class members (ignore 'static' members)
		MEMBERS: Members as an associative array (dictionary) (ignore 'static' members)
	"""
	objClass = obj.__class__.__name__
 
	values = []
	for index, value in obj.__dict__.iteritems():
		values.append(serialize_array_key(index))
		values.append(serialize(value))
 
	return "O:%d:\"%s\":%d:{%s}" % (len(objClass), objClass, len(obj.__dict__), "".join(values))
 

I also wrote up some tests in PHP:

PHP Test Code

<?php
echo "BEGINNING TESTS:\n";
echo "----------------\n\n";
 
//STRING
 
$test = "String";
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize("String")
HEREDOC;
 
print_results("STRINGS", $test, $python);
 
//INTEGER
 
$test = 52;
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize(52)
HEREDOC;
 
print_results("INTEGERS", $test, $python);
 
//DECIMAL
 
$test = 9.8;
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize(9.8)
HEREDOC;
 
print_results("DECIMALS", $test, $python);
 
$test = 1.52*pow(10,-5);
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize(1.52*pow(10,-5))
HEREDOC;
 
print_results("DECIMALS (exponential format)", $test, $python);
 
//BOOLEAN
 
$test = true;
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize(True)
HEREDOC;
 
print_results("BOOLEANS", $test, $python);
 
//NULL
 
$test = null;
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize(None)
HEREDOC;
 
print_results("NULLS", $test, $python);
 
//ARRAY
 
$test = array(9, 8, 7);
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize((9, 8, 7))
HEREDOC;
 
print_results("SIMPLE ARRAYS", $test, $python);
 
$test = array("key" => "value", 5 => "another value");
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize({"key":"value",5:"another value"})
HEREDOC;
 
print_results("ASSOCIATIVE ARRAYS", $test, $python);
 
$test = array("key" => "value", 5 => array("values"));
$python = <<<HEREDOC
import phpserialize
print phpserialize.serialize({"key":"value",5:["values"]})
HEREDOC;
 
print_results("COMPLEX ARRAYS", $test, $python);
 
//OBJECTS
 
class Test
{
	public $i = "PUBLIC";
	public $j = "B0RKED";
}
 
$test = new Test();
$python = <<<HEREDOC
import phpserialize

class Test:
	def __init__(self):
		self.i = "PUBLIC"
		self.j = "B0RKED"
 
print phpserialize.serialize(Test())
HEREDOC;
 
print_results("OBJECTS", $test, $python);
 
function print_results($test_name, $var, $python_code)
{
	echo sprintf( "TESTING %s:\n\n", $test_name );
 
	echo sprintf( "Expecting:  %s\n", serialize($var) );
 
	echo sprintf( "            %s\n", implode("\n            ", explode("\n", print_r($var, true))) );
 
	echo "\n";
 
	$recieved = exec("python -c " . escapeshellarg($python_code));
 
	echo sprintf( "Recieved:   %s\n", $recieved );
 
	echo sprintf( "            %s\n", implode("\n            ", explode("\n", print_r(unserialize($recieved), true))) );
 
	echo "\n---\n\n";
}

Which gives us the following output:

PHP Test Results

BEGINNING TESTS:
----------------

TESTING STRINGS:

Expecting:  s:6:"String";
            String

Recieved:   s:6:"String";
            String

---

TESTING INTEGERS:

Expecting:  i:52;
            52

Recieved:   i:52;
            52

---

TESTING DECIMALS:

Expecting:  d:9.800000000000000710542735760100185871124267578125;
            9.8

Recieved:   d:9.8;
            9.8

---

TESTING DECIMALS (exponential format):

Expecting:  d:1.5200000000000001853270141516372149226299370639026165008544921875E-5;
            1.52E-5

Recieved:   d:1.52e-05;
            1.52E-5

---

TESTING BOOLEANS:

Expecting:  b:1;
            1

Recieved:   b:1;
            1

---

TESTING NULLS:

Expecting:  N;

Recieved:   N;

---

TESTING SIMPLE ARRAYS:

Expecting:  a:3:{i:0;i:9;i:1;i:8;i:2;i:7;}
            Array
            (
                [0] => 9
                [1] => 8
                [2] => 7
            )

Recieved:   a:3:{i:0;i:9;i:1;i:8;i:2;i:7;}
            Array
            (
                [0] => 9
                [1] => 8
                [2] => 7
            )

---

TESTING ASSOCIATIVE ARRAYS:

Expecting:  a:2:{s:3:"key";s:5:"value";i:5;s:13:"another value";}
            Array
            (
                [key] => value
                [5] => another value
            )

Recieved:   a:2:{i:5;s:13:"another value";s:3:"key";s:5:"value";}
            Array
            (
                [5] => another value
                [key] => value
            )

---

TESTING COMPLEX ARRAYS:

Expecting:  a:2:{s:3:"key";s:5:"value";i:5;a:1:{i:0;s:6:"values";}}
            Array
            (
                [key] => value
                [5] => Array
                    (
                        [0] => values
                    )

            )

Recieved:   a:2:{i:5;a:1:{i:0;s:6:"values";}s:3:"key";s:5:"value";}
            Array
            (
                [5] => Array
                    (
                        [0] => values
                    )

                [key] => value
            )

---

TESTING OBJECTS:

Expecting:  O:4:"Test":2:{s:1:"i";s:6:"PUBLIC";s:1:"j";s:6:"B0RKED";}
            Test Object
            (
                [i] => PUBLIC
                [j] => B0RKED
            )

Recieved:   O:4:"Test":2:{s:1:"i";s:6:"PUBLIC";s:1:"j";s:6:"B0RKED";}
            Test Object
            (
                [i] => PUBLIC
                [j] => B0RKED
            )

---

Announcing PHP 5.3: Now With More Bacon!!

Spread the meme.

The easiest way to provide a downloadable file is by altering the headers and echo'ing the file content. In our case:

<?php
header("Content-type: text/csv");
header("Cache-Control: no-store, no-cache");
header('Content-Disposition: attachment; filename="filename.csv"');

We want to set our applicable Content-Type so that the browsers associate the file properly. Just relying on the extension doesn't work, even in Windows. The magic is in the third header setting, "Content-Disposition," which informs the browser to download as a separate file (don't open a new window and display a blank page, just display the file download box) and tell the browser the filename is "filename.csv". This way rewrite rules like http://localhost/export/csv/ will result in a download box that declares the file "filename.csv" rather than a randomly assigned name or whatever the current url is.

Into the meat of the CSV export. At the very beginning we need to open up a stream to the PHP output (the same place where echo sends its string content, which is NOT stdout):

<?php
$outstream = fopen("php://output",'w');
 

Next we're going to assume you already have your data packed nicely into an array (or array of arrays) so long as we have a single array per row/line.

The magic comes into play using the build in PHP function fgetcsv(). fgetcsv() takes an array for a single row and outputs it, automatically escaping output according to column and enclosure delimiters!

fgetcsv() requires a file resource as its first parameter and the magic of PHP streams is they act like a file resource (actually a file resource is just a file stream), so we give it $outstream to make fputcsv() echo its output. We fill in the rest of the parameters according to the php.net documentation and voila we have:

<?php
header("Content-type: text/csv");
header("Cache-Control: no-store, no-cache");
header('Content-Disposition: attachment; filename="filename.csv"');
 
$outstream = fopen("php://output",'w');
 
$test_data = array(
	array( 'Cell 1,A', 'Cell 1,B' ),
	array( 'Cell 2,A', 'Cell 2,B' )
);
 
foreach( $test_data as $row )
{
	fputcsv($outstream, $row, ',', '"');
}
 
fclose($outstream);

For more output stream craziness, zaemis from the #phpc IRC channel on freenode shared a code snipped that outputs CSV either to the output buffer OR will return it as a string using some clever streams hackery:

<?php
function exportCSV($data, $col_headers = array(), $return_string = false)
{
    $stream = ($return_string) ? fopen ('php://temp/maxmemory', 'w+') : fopen ('php://output', 'w');
 
    if (!empty($col_headers))
    {
        fputcsv($stream, $col_headers);
    }
 
    foreach ($data as $record)
    {
        fputcsv($stream, $record);
    }
 
    if ($return_string)
    {
        rewind($stream);
        $retVal = stream_get_contents($stream);
        fclose($stream);
        return $retVal;
    }
    else
    {
        fclose($stream);
    }
}

So ZendCon turned out to be completely worth it, even if only for the chance to meet in person a lot of the core PHP community and then drink semi-copiously with them.

The talks were good, though most of them were either more basic than I would have liked or really indepth (/me thinks back to Sara's PHP Extension Writing talk, though that was more "few php developers gets this deep" than indepth/complicated).

The uncon was nice, which of course I'd like it given my love for barcamps, refreshes, and generally community driven and adhoc events.

The Yahoo party started out awkward given that one expects an open bar after paying $500+ for tickets to a conference, however from what I gathered it really wasn't so much Yahoo's fault more the hotel's. I won the raffle for the "Day with Rasmus" prize and felt bad 'cause when one of the Yahoo girls came to me and to have me verify my information, I told them my email (which was a gmail account) was correct but if they still have trouble to just google my first and last name since I dominate the first page for my name.

My only problem with ZendCon is that it ended...

Where: Murphy's Law (upstairs) [Google Map]
When: October 1st 7PM (Happy Hour starting at 5)
Speaker: Michelle Greer

We've been quiet for a while but it's time to get this show back on the road. We've got several months worth of great speakers lined up and we're starting this thing off with a bang. Michelle Greer has been kicking ass and taking names in the Austin area for quite some time and she has no plans to stop anytime soon. Come listen to her speak about how she uses social media to institute real-life change in the world around us.

Making Social Media Matter:
How Social Media Turns Everyday Citizens into Superheroes

In an age where anyone can publish anything for the cost of hosting a WordPress blog, the means for spreading ideas has never been easier or cheaper. Learn how people have used social media to mobilize people at rates never seen before in history, and how these tools make it easy for you to bring about positive change for your community.

-> Michelle Greer
-> Web Marketing Strategist
-> http://www.michellesblog.net
-> 512.294.3909

If any of you happen to be around college station on the 1st of October, or can make it, I highly suggest you show up to the refresh meetings. Even if the particular topic isn't your cup of tea (if you are a developer and it's a design topic, etc.) it's a great place to connect with people (obviously from the BCS area) and get educated on the happenings on the other side of the fence.

Spoon is both a gentleman AND a scholar.

(And caseysoftware is awesome for the pic)

Sara Golemon gave an interesting introduction to PHP extension writing. I bow to her vastly superior C-fu.

I already discussed a few talks that I went to yesterday as well.

Ended the night doing a pub crawl with some people (hung out with Jay Pipes at the end which is what caused me to regret missing his talk).

He compares software development methodologies to the old TV show Knight Rider, in that the main character, Michael Knight, was average and ordinary except for the fact that he had an applicable toolset for what he needed to do (KITT).

Eli talks about how while locking yourself into a programming language (company wise) is okay in that when you hire you know that the candidate has to know at lease a finite number of languages. But you shouldn't force employees to use locked in tools. If they like their own editor debugger combo, let them use it because they will be faster, the code will still work the same.

He goes over different tools you'll use for different purposes. Editors, debuggers, load testers, etc.

The movie clips are great, which you unfortunately don't get on the downloadable presentation.