The purpose of a collection is to store objects in an organized manner with specific access rules. We are going to build a collection class using the Standard PHP Library (SPL). Our final product will be capable of iterating, counting and access to objects via array. If you are not familiar with SPL you can find some additional information on the PHP SPL manual site. Unfortunately the manual is somewhat lacking. Here is a more detailed list of SPL classes.

We will call our class “Collection” (original, I know). This class will eventually implement the SPL classes: ArrayAccess, Countable and Iterator. If you are unfamiliar with SPL your first reaction may be that you don’t have any of these classes in your project. The beauty of SPL is that the classes are built into PHP (compiled by default). Once you implement a class you are exposed to a series of abstract function which you must implement. Once implemented the result is the ability to manipulate objects and create functionality you wouldn’t normally be able to code.

First we are going to do a quick introduction to the interfaces we will be using. After that we will jump right into code and examples. Please keep in mind that the collection class we are going to build is more about demonstrating the capabilities of these particular SPL interfaces then actual practical use, although you could easily turn this into a useful class.

ArrayAccess
ArrayAccess is an interface that lets you override array access of objects. Basically it lets you use an object as an array and use keys to access values stored within the class.

Abstract Functions

offsetExists($offset)

offsetGet($offset)

offsetSet($offset, $value)

offsetUnset($offset)

Countable
Countable lets you hook into the global count function and override it. We are going to use it to count the number of objects in our collection.

Abstract Functions

count()

Iterator
Iterator allows you to iterator over an object. In our example you will be able to directly loop over a collection and return the objects that are stored.

Abstract Functions

current()

key()

next()

rewind()

valid()

Implementation

The first thing we need to do is define our class. It should look something like this:

<?php

class collection {

    

}

?>

Next we will define a constructor and a private variable called $object that will store the objects we pass into this collection. The constructor will be one way to populate the collection.

class collection {

    private $objects = Array();

    

    public function __construct($objects) {

        if(!empty($objects)) {

            $this->objects = $objects;

        }

    }

}

At this point our class doesn’t do much but take an array of objects and store then in the class. Next we will implement the SPL classes we discussed earlier.

Implement ArrayAccess

class collection implements ArrayAccess {

    private $objects = Array();

    

    public function __construct($objects) { ... }

    

    /** ABSTRACT SPL ArrayAcess **/

    public final function offsetExists($offset) {

        if(isset($this->objects[$offset])){

            return true;

        } else {

            return false;

        }

    }

    

    public final function offsetGet($offset) {

        return $this->objects[$offset];

    }

    

    public final function offsetSet($offset, $value) {

        if($offset) {

            $this->objects[$offset] = $value;

        } else {

            $this->objects[] = $value;

        }

    }

    

    public final function offsetUnset($offset) {

        unset($this->objects[$offset]);

    }

    // End ArrayAccess Abstraction

}

Implement Countable
Countable is really simple to implement and only requires one function. There is an interesting note in the code comment that you should make note of.

class collection implements ArrayAccess, Countable {

    private $objects = Array();



    public function __construct($objects) { ... }



    /** ABSTRACT SPL ArrayAcess **/

    ...

    // End ArrayAccess Abstraction

    

    

    /** ABSTRACT SPL Countable **/

    public function count() {

        // Note from PHP manual: If var is not an array or an object with 

        // implemented Countable interface, 1 will be returned.

        

        // Not sure why it returns one, but we need to make sure our 

        // count is right and returns zero when there are no objects

        if(empty($this->objects)) {}

            return 0;

        } else {

            return count($this->objects);

        }

    }

    // End Countable Abstraction

Implement Iterator

class collection implements ArrayAccess, Countable, Iterator {

    private $objects = Array();

    

    public function __construct($objects) { ... }

    

    /** ABSTRACT SPL ArrayAcess **/

    ...

    // End ArrayAccess Abstraction



    

    /** ABSTRACT SPL Countable **/

    ...

    // End Countable Abstraction

    

    

    /** ABSTRACT SPL Iterator **/

    public function current() {

        return current($this->objects);

    }



    public function key() {

        return key($this->objects);

    }

    

    public function next() {

        return next($this->objects);

    }

    

    

    public function rewind() {

        if(empty($this->objects)) {

            return false;

        }

            

        return reset($this->objects);

    }

    

    

    public function valid() {

        if(empty($this->objects)) {

            return false;

        } else if(current($this->objects) === false) {

            return false;

        } else {

            return true;

        }

    }

    // END Iterator Abstraction

}

Final Collection

Our completed class isnt all that complicated. But its extremely powerful if used the right way. Hopefully you were able to follow along and understand what we have built. The final code is posted below as well as a test case in the next section. I recommend running the test to really see what the class is capable of doing.

<?php



class collection implements ArrayAccess, Countable, Iterator {

    private $objects = Array();

    

    public function __construct($objects) {

        if(!empty($objects)) {

            $this->objects = $objects;

        }

    }

    

    /** ABSTRACT SPL ArrayAcess **/

    public final function offsetExists($offset) {

        if(isset($this->objects[$offset])){

            return true;

        } else {

            return false;

        }

    }

    

    public final function offsetGet($offset) {

        return $this->objects[$offset];

    }

    

    public final function offsetSet($offset, $value) {

        if($offset) {

            $this->objects[$offset] = $value;

        } else {

            $this->objects[] = $value;

        }

    }

    

    public final function offsetUnset($offset) {

        unset($this->objects[$offset]);

    }

    // End ArrayAccess Abstraction



    

    /** ABSTRACT SPL Countable **/

    public function count() {

        // Note from PHP manual: If var is not an array or an object with 

        // implemented Countable interface, 1 will be returned.

        

        // Not sure why it returns one, but we need to make sure our 

        // count is right and returns zero when there are no objects

        if(empty($this->objects)) {

            return 0;

        } else {

            return count($this->objects);

        }

    }

    // End Countable Abstraction

    

    

    /** ABSTRACT SPL Iterator **/

    public function current() {

        return current($this->objects);

    }



    public function key() {

        return key($this->objects);

    }

    

    public function next() {

        return next($this->objects);

    }

    

    

    public function rewind() {

        if(empty($this->objects)) {

            return false;

        }

            

        return reset($this->objects);

    }

    

    

    public function valid() {

        if(empty($this->objects)) {

            return false;

        } else if(current($this->objects) === false) {

            return false;

        } else {

            return true;

        }

    }

    // END Iterator Abstraction

}

?>

Testing and Demonstration

Test Code

<?php



/** FOO CLASS USED TO POPULATE OUR TEST COLLECTION */

class Foo {

    public $value;

    

    public function __construct($value) {

        $this->value = $value;

    }

}





/** DEMONSTRATION **/

$objects = Array();

for($x = 0; $x < 5; $x ++) {

    $objects[] = new Foo($x);

}



$collection = new Collection($objects);



// offsetExists

if(isset($collection[3])) {

    echo "Offset 3 exists\n";

} else {

    echo "Offset 3 doesnt exist\n\n";

}



// offsetGet

echo "Value of offset 1: " . $collection[1]->value . "\n";



// offsetSet

$collection[3] = new Foo('A');

echo "Offset 3 has been changed, the object value is now: " . $collection[3]->value . "\n";



// offsetUnset

unset($collection[2]);

echo "Offset 2 has been removed. ";



if(isset($collection[2])) {

    echo "Offset 2 exists\n";

} else {

    echo "Offset 2 doesnt exist\n\n";

}





// Countable

echo "This collection has " . count($collection) . " objects\n\n";





// Iterating

echo "Looping through our collection:\n";

foreach($collection as $key => $object) {

    echo "Index " . $key . " = " . $object->value . "\n";

}



?>

Test Output

Offset 3 exists

Value of offset 1: 1

Offset 3 has been changed, the object value is now: A

Offset 2 has been removed. Offset 2 doesnt exist



This collection has 4 objects



Looping through our collection:

Index 0 = 0

Index 1 = 1

Index 3 = A

Index 4 = 4

There is a much easier way… S3 allows you to set request headers on a per object basis. In order to force a file download dialog you just need to set the “Content-Disposition” header.

Here’s an example using the Undesigned Amazon S3 PHP class (highly recommended). This header should easily integrate into whatever system you are using to interact with the S3 API. If you need additional information take a look at the S3 documentation.

Let’s jump right into the class setup… Our cache class is a completely static class and can’t be instantiated on its own. When our application starts up a create_instance function is called which will create a connection to memcache in a static object stored in our class. Shortly after the instance is created, our config file is loaded and we add the servers that make up our memcache pool. Really nothing fancy happening thus far…

Besides the create_instance and the add_server functions our class only has three main public functions; get, set and delete. When I say main, those are really the only three functions we use throughout our application, everything else is for internal use by the cache class. There are also a few logging and stats functions which aren’t important for this article.

Set Function

public static function set($key, $value, $expire = -1) {

    if ($expire == -1)

        return true;



    // there was no key passed, to be safe we will create one

    if (!strlen($key))

        $key = md5($value);



    $value = self::falsify($value);



    self::instance_set($key, $value); // set the instance cache

    self::$memcache->set($key, self::dogpile_set($value, $expire), MEMCACHE_COMPRESSED, $expire + self::EXTENDED_LIFE); // set memcache

}

Let me explain what’s going on and why… The set function takes 3 parameters: $key, $value and $expire.

1) Check the $expire value. If the expiration is less than zero (we default to -1) we assume this wasn’t meant to be cached and we just return true.

2) Make sure there was a $key passed. If there isn’t a key, we play it safe and set $key equal to the MD5 of the $value. Otherwise, there is a chance of key collisions. We definitely don’t want that.

3) We run the $value through a function called “falsify”. We found that storing the actual value of “false” caused a number of issues. The first being that we interface very closely with our database layer. If our get function returns false, the database layer assumes it didn’t find a value in cache and does a query (more on the solution to this in the get section). Second, the get function will return false when it fails to find data. The solution was the falsify function. It looks at the value and if it’s false the value is turned into a special string we can later identify. Something like “<-F4LS3->”. Basically a value that would never normally be stored. Later on in the get function we will use this to identify the difference between a stored false and not finding results.

4) We created a local instance cache that stores any data we get/set in a static array. This helps prevent unnecessary subsequent requests for data we may have already retrieved. We do this by passing the key/value to an instance_set function which stores the data by its key.

5) Sites with high loads are often subject to the dogpile effect. Basically, if something falls out of cache and two or more users make the same request and receive a miss from memcache, they end up performing the same operation (usually a database query) to refresh the data. For smaller sites the extra database work is fairly minor. But larger sites under heavy load often can’t afford this. Think about something falling out of cache on the homepage of a large site. This could generate hundreds of the same query, locking up tables and eventually bring the database to a crawl. I have seen it, it’s not that awesome.

The way we deal with this problem is by passing the value and expiration time to a function called set_dogpile. This function is simple and you will understand its purpose later on… All this function does is create an array with the key “v” and stores the $value and a key called “t” where we store the $expire and then returns the array.

private static function dogpile_set($data, $expire) {

    return array('t' => time() + $expire, 'v' => $data);

}

6) Finally we can write our data to memcache! We set the key to the $key we were originally passed and the value to the array that was returned from dogpile_set. The expiration time is slightly more complicated. Our cache class has a constant variable called “extended_life”. We use this in conjunction with the dogpile effect prevention. Our extended life is set to 300 seconds. This will be better explained in the get section below, bare with me for now. Set the expiration to the $expire value passed in + the extended_life.

*Its important to note that the version of data stored in the instance cache (Step 4) is the original data, not the dogpile array.

Get Function

public static function get($key, &$found = null) {

    if(is_array($key)) {

        // Not used for the purpose of this article

        // $value = self::get_complex($key);

        } else {

            $value = self::get_simple($key);

        }



        if($value === false) {

            $found = false;

            

            return false;

        } else {

    

        $found = true;



        if(is_array($value))

            return $value; // complex response (not used in this article)

        else

            return self::defalsify($value); // simple response

    }

}

The get function takes two parameters: The first is the $key and the second is an optional referenced parameter called &$found (default to null).

Our get function can take two types of keys. Either a single key request as a string or multiple key requests as an array. The first thing we do in the get function is determine the key type. If it’s a string we send the key off to the “get_simple” function. If it’s an array it goes to the “get_complex” function. For simplicity reasons we are only going to focus on the get_basic function.

If you do explore get_complex on your own, keep in mind that memcache can take an array of keys and retrieve those results in a single request. You will also need to keep track of what is and isn’t found from the instance cache. That way we can do lookups from memcache on the missed keys. There is an example of get_complex at the very end of this article, it should be easy to understand after you grasp get_basic.

Get Simple

private static function get_simple($key) {

    $value = self::instance_get($key);



    // instance cache returned nothing, look it up

    if(!$value) {

        $value = self::dogpile_get($key, self::$memcache->get($key));



    if(!empty($value)) {

        // results were found in memcache, lets add it to the instance cache

        self::instance_set($key, $value);

    } else {

        // nothing was found, return

        return false;

        }

    }



    return $value;

}

1) First the key is passed to the “get_instance” function. This function checks our static instance array to see if we have already performed a get or set for that key. If data is found, return it, otherwise return false.

We are back in the get_basic function now. If the value returned from get_instance isn’t false, we return the value back to “get”.

2) If the value returned from get_instance is false we need to ask memcache for the data. You should do that now.

Whatever the response is from memcache we will pass the key and the data to the dogpile_get function.

private static function dogpile_get($key, $data) {

    if(!empty($data)) {

        $value = $data['v'];



        if($data['t'] > 0) {

            if(time() >= $data['t']) {

                $data['t'] = time() + self::DELAY; // Update the cache time



                // set the stale value back to memcache for a short 'delay' so no one else tries to write the same data

                self::$memcache->set($key, $data, MEMCACHE_COMPRESSED, self::DELAY);



                return false;

            }

        }



        return $value;

    }



    return false;

}

a. First we need to make sure the value isn’t an empty array. If it fails that check we assume the data is corrupt or snuck into memcache and we return false. If everything looks good, extract the value from the “v” index and the time from the “t” index.

b. Make sure the “t” value is greater then 0. If its not, return the “v” value.

c. Check if the current time is greater than or equal to the “t” value. This is where our dogpile magic happens. The extended_life we set earlier gives us an extra few minutes to let the application determine what’s stale and what’s valid. The “t” value is the actual time we want the data to expire even thought we told memcache to store it for an extra few minutes. Since we got this far, it means the data is meant to expire. To prevent everyone and their mother from reloading the cache we are going to temporarily store the old stale data back in memcache while this user has the opportunity to refresh it.

We need to update the “t” value of the data array that was passed in to be the current time + $delay. Delay is a constant integer; we have out set to 30 seconds (change as needed). This delay is our dogpile buildup prevention. You will see how in a moment… Now we write the stale data back to memcache. Set the key to the $key that was passed in, the value to our updated $data array and the expiration to $delay. Now for the next 30 seconds all subsequent requests will receive the stale data (shouldn’t be a big deal for most sites). The user who found the stale data now has 30 seconds to complete an update. If she fails to do so, the next user to make the request will have that opportunity. Return false, because we want to the request to think we found nothing and fetch fresh data.

3) Now that we have our response and have dealt with dogpiling we need to analyze the response. If the value from get_simple is false we need to set &$found to false and return false. The found variable does exactly as you probably guessed. It tells us if the get function really found something (even if the value was stored as false). It’s a referenced variable, so we can easily use it outside of the cache class.

If the response is not false we set &$found to true and pass the data off to the defalsify function, which compares the value to our constant “false identifier” (<-F4LS3->). If the value equals the identifier, return false. Now the “get” function can finally return the results.

Delete Function

The delete functionality is simple compared to the get/set functionality. The goal is to delete the data from the instance cache and from memcache. This is easily shown with an example.

public static function delete($keys) {

    if(!is_array($keys))

        $keys = array($keys);



    if($keys) {

        foreach($keys as $key) {

            self::$memcache->delete($key);

            self::instance_delete($key);

        }

    }

}

Conclusion

I hope this article gives you a better insight into some more advanced caching techniques. I, nor CollegeHumor claim to have invented any of these techniques or methods. This was a high level overview of how our caching layer functions and I hope someone learned something from it. I know it might be difficult to follow all the operations, unfortunately I cant post the entire class code. But, if you have any questions about implementation, caching or anything PHP, feel free to contact me or post a comment.

Get Complex

private static function get_complex($keys) {

    $results = array();

    $missing = array();

    $num_keys = count($keys);



    // lets see if we can find any of these in the instance cache first

    for($x = 0; $x < $num_keys; $x++) {

        $key = $keys[$x];

        $value = self::instance_get($key);

        

        if(!$value) {           

            // nothing was found in the instance cache, lets create a list to look them up in memcache          

            $missing[] = $key;      

        } else {            

            // we found what we were looking for in instance cache!             

            $results[$key] = self::defalsify($value);       

        }   

    }   

    

    if(empty($missing))         

        return $results; // we found everything we need in instance cache   

        

    // look up anything thats missing in memcache   

    $values = self::$memcache->get($missing);



    if(!empty($values)) {

        foreach($values as $key => $value) {

            $value = self::dogpile_get($key, $value);



            if($value) {

                $results[$key] = self::defalsify($value);



                self::instance_set($key, $value);

            }



        }

    } else {

        // we didnt find what we needed in memcache

        return false;

    }



    return $results;

}

I personally don’t have much experience with open source (or enterprise) CMS. I had a short stint with Joomla and eventually ditched it. I have become a bit of a development control freak. More often than not I prefer to roll my own system. This isn’t for everyone and doesn’t make sense for all projects.

My problem with pre designed Content Management Systems, is it tries to solve a problem that can’t always be solved with single solution. A fits everything package usually comes with overhead, constraints and a little bit of a development black hole. These constraints can lead to excessive amounts of “work arounds”, hacks and a lack of understanding. On the other hand a pre packaged solution comes with an entire community of developers, tutorials, patches and plugins. Having resources like that can save time and money. It really comes down to what’s best for your project.

Choosing to build your own system or use an existing one depends on the scope of the project and your skill level. These are a few key points I would pay attention to while making a decision:

• How many users will be using your site? Theres a big difference between a 10 user intranet application and a million user application.
• What is the timeline for development?
• What kind of budget are you working with?
• How active is the community that maintains and contributes to the CMS?
• How much of the CMS will you have to customize? Are there plugins that do what you need?

For a site like CollegeHumor, we needed to understand and control every line of code. Everything from the framework to the content management application is all home grown. But like I said before this doesn’t make sense for everyone. If you are building a small intranet site and can do the bulk of the work in a CMS, there is no reason to reinvent the wheel. If your site handles several million hits a day you may not want the extra overhead that a CMS comes with maybe rolling your own makes sense. Evaluate what you are working with and make a choice that best fits your project.

Step 1) Log in to Facebook and browse to the event “Invite people to come” page.

2) Setup a new bookmarklet with this code (or optionally paste in the address bar on that page):

3) Click the bookmarklet and enter 0 when prompted. (0 represents your current offset, you will need to keep track of this.)

4) Click invite

5) Repeat and increase the offset by 100 until all friends have been sent invites

– Response:

Array (

    [0] => 1

    [1] => 2

    [2] => 3

    [3] => 4

    [4] => 5

    [5] => 6

    [6] => 7

    [7] => 8

    [8] => 9

)

</pre>
]]>
			http://www.adamgotterer.com/2008/12/19/php-recursive-multidimensional-array-flatten-using-spl/feed/
		0
		
		
		
		http://www.adamgotterer.com/2008/07/22/recursive-php-in_array-function/
		http://www.adamgotterer.com/2008/07/22/recursive-php-in_array-function/#comments
		Tue, 22 Jul 2008 23:41:51 +0000
		Adam
				

		http://www.adamgotterer.com/2008/07/22/recursive-php-in_array-function/
		
			I needed a recursive in_array function the other day and disliked all the samples I found on php.net. I wrote this one using the StandardPHPLibrary. It will recursively search through a multidimensional array and return true if the $needle is found in the $haystack.

function in_array_recursive($needle, $haystack) {



    $it = new RecursiveIteratorIterator(new RecursiveArrayIterator($haystack));



    foreach($it AS $element) {

        if($element == $needle) {

            return true;

        }

    }



    return false;

}

]]>
			http://www.adamgotterer.com/2008/07/22/recursive-php-in_array-function/feed/
		1
		
		
		
		http://www.adamgotterer.com/2008/05/28/weebly-puzzle/
		http://www.adamgotterer.com/2008/05/28/weebly-puzzle/#comments
		Wed, 28 May 2008 05:06:51 +0000
		Adam
				
		
		

		http://www.adamgotterer.com/2008/05/28/weebly-puzzle/
		
			This site attracts a decent amount of JavaScript folks so I thought this would be relevant and maybe even helpful. I read news.ycombinator.com everyday (or several times a day). If you are into the startup world, you should as well. It has by far the best startup news and a great community. The feedback and questions posted on there are generally informative and trolling is at a bare minimum. It’s what reddit used to be. Regardless, I came across a job posting at Weebly for a web developer position. The job description came with a little JavaScript puzzle. I had no intention of actually applying for the job, but when ever I find these puzzles I like to do them. I’m not going to post the results, because thats not cool. If you want to check your answer email me your best guess. But it entertained me for about 20 minutes. So if you’re bored or actually looking for a job check it out at http://www.weebly.com/jobs.html.

]]>
			http://www.adamgotterer.com/2008/05/28/weebly-puzzle/feed/
		1
		
		
		
		http://www.adamgotterer.com/2008/04/03/muxtapes-is-growing-fast/
		http://www.adamgotterer.com/2008/04/03/muxtapes-is-growing-fast/#comments
		Thu, 03 Apr 2008 18:09:42 +0000
		Adam
				

		http://www.adamgotterer.com/2008/04/03/muxtapes-is-growing-fast/
		
			

On Tuesday March 25th, Justin Ouellette one of the developers from Vimeo launched Muxtape as a side project. The idea isn’t totally original, but its executed far better then the competition. Muxtape is a site that lets you make virtual mix tapes. You upload up to 12 songs from your computer and share the custom link with anyone who wants to listen. The design is one of the cleanest and easiest to use sites I have ever seen.
When Justin sent out an office wide link looking for feedback on Tuesday morning I googled “muxtape” and got back 33 results. I did the same thing the Wednesday and got back around 4,000 results. Thursday was around 9,000 and Friday around 22,000. I didn’t check over the weekend. I looked sometime early the next week and saw it was over 40,000. Tuesday April 1st, one week after the site launched google returned just over 100,000 results and as of today (April 4th) 121,000 result. That growth rate is pretty unbelievable and I would love to see at what point it stabilizes.
I talked to Justin today about the growth on his site, I don’t want to throw numbers out without his permission but he said the site is growing at a nice rate every day. I assure you it’s a pretty impressive number for a site two weeks old. He must be paying a fortune in bandwidth on Amazon S3. I want to say that he didn’t have a clue how big this was going to get, but then I would be lying. I think he knew damn well how the site was going to do before he even launched. He gave Vimeo two weeks notice Monday, the day before he launched. Thats a pretty ballsy move to go from a stable income to the unknown. But thats what separates the people who build great companies and the people who are too afraid and work corporate the rest of their life. I don’t know Justin that well, but I have had some interesting conversations with him and he really knows his stuff. He didn’t give me much insight to future plans. But he said theres a monetization plan in the works and a bunch of new feature. I think he is going to do great and wish him the best of luck.
Check out my Muxtape!
]]>
			http://www.adamgotterer.com/2008/04/03/muxtapes-is-growing-fast/feed/
		0
		
		
		
		http://www.adamgotterer.com/2008/04/01/bustedtees-relaunch/
		http://www.adamgotterer.com/2008/04/01/bustedtees-relaunch/#comments
		Tue, 01 Apr 2008 21:07:00 +0000
		Adam
				
		
		

		http://www.adamgotterer.com/2008/04/01/bustedtees-relaunch/
		
			

This morning at 5am Kunal Shah, Nick Dunkman, Jmo and myself launched a new version of the BustedTees website! Visually the site hasn’t changed much. Amir Cohen, one the front end developer for CollegeHumor did an excellent job recoding the front end. We spent the better part of the last 4 months recoding everything from scratch. The original version was built on the open source Symfony PHP framework several years ago (before my time). The site served it’s purpose and helped take BustedTees to a new level, it wasn’t that it was poorly programmed, it just outgrew our requirements. 

(Dev Team at 5:15am)
I’m finding that a lot of the open source PHP frameworks that I have experimented with and seen throughout the community just don’t scale well. They serve a purpose and are great for average every day sites. But when dealing with a site the size of a BustedTees or CollegeHumor it really makes sense to roll your own framework, if you can. There are of course instances when writing a framework from scratch doesn’t always make sense. In the “unsure” startup setting it sometimes makes sense to get something out there quick and worry about scaling later. Scaling is a GREAT problem to have. If you are going to use open source code, not just frameworks, it’s important to really understand the underlying code. I can bet most coders don’t have a clue how the open source code they use actually works. Some of these applications are coded by excellent developers, you might learn something new by just reading their code.
Working on BustedTees has been an incredible experience and I have learned so much. I have worked on some small ecommerce sites as a freelance developer, but nothing of this size. Theres so many things I would have never thought needed to be accounted for. In future posts I will try and elaborate a bit. Right now I’m running on a few hours of sleep I got from a nap, so I’m going to pass out…
]]>
			http://www.adamgotterer.com/2008/04/01/bustedtees-relaunch/feed/
		0