That’s not a bad thing. Being agile and able to switch out database systems with minimal fuss possible is good programming practice. And MySQL, while it’s a good lightweight system that fits a lot of people’s needs, isn’t he only game out there.

PostgreSQL is one of the other options out there. It may not get as much press as its more famous little brother, but it’s also open and free.

Postgres is also a great alternative for government or corporate ‘enterprise’ projects that may have thumbed their nose at MySQL before, however unfairly, as a ‘toy’ database. It’s built for security, stability, and has the transaction support and advanced features that high end Oracle users want, while still being easy to use and accessible for users without as many resources.

Also, MySQL users, no more will you have to worry about needing different features that are supported in different storage engines. There is only one storage engine. All features are in one place. You can have fulltext search and foreign keys!

It honestly can be a little bit more work to set up than MySQL on a linux server, due mainly to the way its user-based permission system works, but it can actually be a great security feature, and there are some excellent tutorials out there that you can follow to get it up and running with minimum fuss.

I’ve started using PostgreSQL in some of my projects. It is a great system that at least deserves a look. If you decide that MySQL is still the database for you, no worries. The Sun/Oracle acquisition just underlines the importance of being flexible in your development. If all that happens is programmers start being a little more modular and careful in planning their systems, putting all their database code in one place so it’s easy to replace, that’s not a bad thing at all.

Let’s take a look at building out our own basic collection class. We can extend and subclass this thing later to make it even more useful.

class Collection implements IteratorAggregate, Countable
{
        /** hold the colleciton of items in an array */
        protected $_items = array();

        /**
         * Optionally accept an array of items to use for the collection, if provided
         * @params array $items (optional)
         */
        public function __construct($items = null)
        {
                if ($items !== null && is_array($items)) {
                        $this->_items = $items;
                }
        }

        /**
         * Function to satisfy the IteratorAggregate interface.  Sets an
         * ArrayIterator instance for the server list to allow this class to be
         * iterable like an array.
         */
        public function getIterator()
        {
                return new ArrayIterator($this->_items);
        }

        /**
         * Function to satisfy the Countable interface, returns a count of the
         * length of the collection
         * @return int the collection length
         */
        public function count()
        {
                return $this->length();
        }

        /**
         * Function to add an item to the Collection, optionally specifying
         * the key to access the item with.  Returns the item passed in for
         * continuing work.
         * @param $item the object to add
         * @param $key the accessor key (optional)
         * @return mixed the item
         */
        public function addItem($item, $key = null)
        {
                if($key !== null) {
                        $this->_items[$key] = $item;
                } else {
                        $this->_items[] = $item;
                }

                return $item;
        }

        /**
         * Remove an item from the Collection identified by it's key
         * @param $key the identifying key of the item to remove
         */
        public function removeItem($key)
        {
                if(isset($this->_items[$key])) {
                        unset($this->_items[$key]);
                } else {
                        throw new Exception("Invalid key $key specified.");
                }
        }

        /**
         * Retrieve an item from the collection as identified by its key
         * @param $key the identifying key of the item to remove
         * @return item identified by the key
         */
        public function getItem($key)
        {
                if(isset($this->_items[$key])) {
                        return $this->_items[$key];
                } else {
                        throw new Exception("Invalid key $key specified.");
                }
        }

        /**
         * Function to return the entire list of servers as an array
         * of Server objects
         * @return array
         */
        public function getAll()
        {
                return $this->_items;
        }

        /**
         * Return the list of keys to all objects in the collection
         * @return array an array of items
         */
        public function keys()
        {
                return array_keys($this->_items);
        }

        /**
         * Return the length of the collection of items
         * @return int the size of the collection
         */
        public function length()
        {
                return count($this->_items);
        }

        /**
         * Check if an item with the identified key exists in the Collection
         * @param $key the key of the item to check
         * @return bool if the item is in the Collection
         */
        public function exists($key)
        {
                return (isset($this->_items[$key]));
        }

}

This is fairly basic, but it’s already got some pretty useful stuff. We can add, remove, and retrieve items in this collection, as you’d expect. We can check to see if an item exists. Also, notice that we’re returning the object in question when we add it, so we can support some handy command chainging functionality. But we’ve got some other nifty features as well.

This Collection is iterrable (not irritable, it’s not grumpy). So you can just cycle over the whole thing in a foreach loop, just like an array. It does this by implementing the IteratorAggregate interface, which requires a function getIterator() to return an iterator object. The iterator it returns is just the array iterator created from the protected items array.

We’re also countable, by implementing the Countable interface. It requires one function count() which we just pass along to our length() function which returns the count of the items in our collection. Why have length()? Why not just return a count of our array in the count() method? So we can get the number of items two ways, either by count($collection) or $collection->length(). We like flexibility.

We also have some nice functions, getAll(), keys() which let us get the entire collection as an array (in case we absolutely need an array for something we’re working with), and to return a list of all the object keys in the array.

We can stuff just about anything we want in this collection, ints, strings, objects, and more. And it’s got some built-in behaviors that we’re used to seeing from arrays. But why go through all this trouble? Why not just use an array and call it a day?

Because this puppy’s extendable through the magic of Object-Oriented Inheritance!

I can easily add a method to this Collection class or a sub-class to support some specialized behavior. Say I created a subclass AggregateCollection that had a method that cycles through and gets an aggregate total of some certain property of every item in the collection:

        public function getAggregateProperty($property)
        {
                $total = 0;
                if (count($this) > 0){
                        foreach ($this->_items as $item) {
                                if ($item instanceof AggregateCollection) {
                                        $total += $item->getAggregateProperty($property);
                                } else {
                                        if ($item->$property !== null) {
                                                $total += $item->$property;
                                        }
                                }
                        }
                }
                return $total;
        }

What’s this doing? We’re looping through the entire set of objects we have and aggregating the total of whatever property we passed in. Not only that, but we can even have a collection of collections, so we check to see if the child we have is a collection, and then call its method to get the aggregate properties of its items. This will extend as far down the chain as we need, so we can have an extensive hierarchial relationship of items, and with one method call:

$total = $collection->getAggregateProperty('someProperty');

And we don’t even need to know how far down the rabbit hole we need to go to get it.

Another thing I find pretty helpful, especially in light of how I like to chain commands, is a method something like this:

        public function getOrMakeChild($id, $type, $params = null)
        {
                if ($this->exists($id)) {
                        return $this->getItem($id);
                } else {
                        $child = new $type($params);
                        return $this->addItem($child, $id);
                }
        }

You can then in one call first check to see if an item exists by key, and if so, return the item to begin working with. If it doesn’t exist, it creates a new object based on the type you give it, then returns it. This can be any type of object that takes either zero or one parameter which you can optionally pass in with the call.

As you can see, you can build out your collection objects to do almost anything you need, making these a flexible, powerful alternative to arrays.

However, another thing that many JQuery programmers really appreciate is the command chaining lets you pipe the object from one statement to another, futher shrinking the number of lines of code and in the process making it easy to just do a lot of different things in a row to one object.

$('.selectableClass').removeClass('selectableClass')
.addClass('unselectableClass').parent().children().slideUp();

That code is really concise, but it’s still pretty self-explanatory what’s going on. It doesn’t reach the level of unreasonable terseness of, say, the frackin’ ternary operator. (die ternary die!).

Wouldn’t it be great to make some of your PHP objects act like that? Guess what? You can!

There are a number of design patterns that can encourage working in your code this way. Decorators, for example. Obviously the factory pattern is all about creating and using brand new objects.

All you have to do is just pass the object you’re wanting to chain along back as the result of a method call. For example, you might have some kind of collection object that you add a new item to and then want to use that item immediately, as in the following example:

public function addItem($childItem) {
// add the child item
return $childItem
}

That’s all there is to it. You can then call the function like:

$collection->addItem(new childItem())->doSomethingOnChild();

In a more concrete example, say you’re creating a spreadsheet. You may want to create a new worksheet and new row all from a database.

$spreadsheet = new Spreadsheet()->addWorksheet(new Worksheet())->addRow(new Row())->manipulateRow();

Here, we’re piping in new objects as we create them and then using them right away.

Obviously this can get to be too much, so don’t go overboard with it. The above is getting a little bit long. But it can be a great practice to learn for certain design patterns and for hierarchial object relationships. And it shows that there’s more than one way to code your objects. It’s all about options.

There are no style restrictions, and editing is actually discouraged. The goal is to get out and write, to just splurge everything down on the paper and get an actual novel completed, instead of endlessly thinking about the plot, or getting caught in the tinkering trap of endlessly tweaking and rewriting things.

There’s no contest, and no prize for best novel. The only prize is to have a complete 50,000 word piece of writing that you’ve created.

I’ve been neglecting my writing lately. Instead anything I create is more likely to be crafted in PHP or C# than the English language. Don’t get me wrong, I do enjoy grokking a tricky piece of code, but there’s a more creative side to myself that I’ve always enjoyed exploring, and it hasn’t been getting much play lately. It will feel good to get back to actual writing again.  I feel like the NaNoWriMo challenge is exactly the sort of event I need to get started again.

So that leaves me with a little more than one month to get ready.  I need set up a space to write, find some typing paper (yes I’m using a typewriter), and figure out what to write.  Anyone have any suggestions?

While there certainly are some libraries or frameworks that are too big or that run slower, that’s more a sign of a poorly made library than anything else. JQuery is no poorly made library.

You may load an extra few killobytes of data once, but you more than make up for that in the code you don’t write.  That 15k contains lots of time and code-saving features that can help turn something that used to take you 5 lines of code into an elegant one-liner, streamlining your code and actually making your JavaScript more efficient.

The first time I saw how much power was wrapped up in simple the simple calls of JQuery, I had gone to Desert Code Camp, basically a free coder’s day camp in Phoenix with presentations on a bunch of different topics.  Looking to fill in time before the Cocoa programming intro, I hopped into the JQuery session.

The first thing the presenter did was probably familiar to many who have used JQuery before.  He wrote a two-inch single line of code to perform list striping, that effect you get when every other line in a list or table is a separate background color.
$("tr:even").css("background-color", "#eeeeee");
He then went on to show off a couple of one-line effects like fading, roll-ups, show/hide, and while he was at it he showed off some of the drop-dead simple css-based selectors to get just the right items.

Needless to say I immediately went home and jumped on the jquery site, picked up a book on JQuery, and started learning the syntax.  Since then I’ve started working it into my own projects and projects at work.  I’ve even started rewriting some old stuff to use JQuery simply because it’s that much better.  Projects at work that would have taken me two weeks or more I’m able to get done in under a week with the time I’m saving from JQuery.

Does this all sound a little hard to believe?  An exaggeration?  Can it end World Hunger, too?  Nope, I guarantee it’s real, and once you start seeing your code collapsing into half its previous size, you’ll wonder why you’d never learned JQuery sooner.

Ready to dive in?  Honestly there’s not a lot to learn to get started.  Simply run over to JQuery’s site and start looking through the documentation, run to Borders and pick up a book, check out 15 Days of JQuery and run through their demos.

The coolest part about all this is that I wasn’t the only one who was excited about this (nor probably the most excited). My 7 year old stepson Johnny just about imploded with excitement when he found out.

Johnny’s a huge Bill Nye fan. He watches the Bill Nye videos and reads Bill’s books from the local library like a lot of kids his age play video games (he really likes video games, too). So Isa and I decided that it would be a good surprise to take him to this talk…of Science!

We didn’t tell him we were going. That day we left my parents after visiting for the day, and instead of driving straight home, we drove to SLU. When we parked, Johnny asked why we were stopping.

‘We just feel like getting out and walking around for a minute.’

He didn’t question at all, but just got out and walked with us, even though it was pretty cold.

Finally, we passed by a sign as we were getting close to the assembly hall with a big picture of his Science-ness on it.

“We’re going to get to see Bill Nye?” Johnny all but vibrated through the floor.

So we continued in to the convention room to hear Bill speak about environmental sustainability to a bunch of college students.  We figured it would be cool for Johnny to get to see Bill Nye in person, but that he probably wouldn’t get much out of it considering the target crowd.

“I’m going to remember this everyday for all my life,” Johnny proclaimed.

The next day we were visiting my parents, and Johnny was telling them all about how we were part of the ‘Space Generation’ and how the sky on Mars is beige in color.

Sounds like we’ve got another little ‘Science Guy’ developing already.

To catch you up on the goings-on, here is the official Cliff’s notes version of the last few months of my life, with full version to follow shortly.

First up, I got married. After a year up planning the Big Day finally arrived. The ceremony was great, the church was beautiful and everything went off without a problem. The reception afterward was very elegant, everyone said so. And–very importantly for us–the photos came out great.

Well getting married was a lot to plan, but a few weeks before the wedding I found out I got an excellent new job at GoDaddy. In Arizona. So in the last couple weeks before the wedding we also had a move to plan. Fortunately Isa’s the plan ahead type and everything went smoothly.

When we got down here of course we needed to find a place to live, and then here was settling into the new job. Then, just about a month ago, my Dad found out he was going to need bypass surgery. I flew back and my brother drove home from school to be there. Fortunately the doctors found his blockages before he had a heart attack, and they’re getting really handy with heart surgery nowadays. It’s almost become a routine thing. Still it is a pretty big event and can really make you worry.

Finally, just this week, Isa and I made the switch and got iPhones, on which I am composing this post.

Anyway, that catches up most of the major events that have been occuring lately. Hopefully things have settled enough that I’ll be able to keep connected more, and maybe be able to get back to working on my movie reviews site.

Conditionals aren’t too hard.  The most basic form of a conditional is the ‘If’ statement.

If something is true…
Then do something else

In PHP this is written like so…

if (something) {
something else
}

Let’s look at an example.

$a = 2;
$b = 1;
if ($a > $b){
echo $a;
}

So in this example, we first test whether $a is greater than $b (using the > symbol again from Algebra).  If this is true, we print the value of $a.  In this case, the browser would see the number 2 because $a is indeed greater than $b.

However, say $b was equal to 3.  In that case, we would not print the value of a, and the PHP interpreter would simply continue its merry little way on to the rest of the code.

You can put more than one statement in the curly braces of an ‘If’ statement, by the way.  We could also have:

if ($a > $b){
echo ‘A is greater<br />’;
echo $a;
}

This would output:

A is greater
2

Notice I included the html <br /> in there.  You have to include whatever html tags you need, including line breaks, inside the strings you send to PHP.

Now what if we wanted to test to see if $a and $b were equal?  Well, like I mentioned in the previous section, we use two equals signs for this:

if ($a == $b){
echo ‘They are equal’;
}

If the two numbers are equal, and only if they are equal, the browser will see ‘They are equal’ printed.

However, as I warned before, you must be careful not to use the single equals sign for this.

if ($a = $b){
echo ‘They are equal’;
}

Because that will assign the value of $b to $a.  So even if $a started out as 3 and $b started out as 56, this would be considered a true statement, because PHP would assign the value of 56 to $a, and then declare it a true statement.  So our browser would always see ‘They are equal’ even if they are not.

Using our form example from a past lesson, we could display a message only if someone put ‘Fred’ in as their username.

if( $_POST[‘username’] == ‘fred’){
echo ‘Heya Fred!’;
}

So you can hopefully begin to see how some of the magic happens when you send that web form.

+      adds numbers
-    subtracts
*    multiplies
/    divides
%    modulus (the remainder of a division)

These are pretty common and you’re probably pretty familiar with these.  Though the modulus operator at the bottom may be a bit strange.  It’s needed because if you divide two integers, PHP is still going to return an integer with no decimal or remainder.  For example:

echo 5/2;

Would output

2

If you were to use:

echo 5%2;

You would get 1, which is the remainder of 5 divided by 2.

Notice that the numbers don’t have quotation marks around them like text does.  Numbers don’t need them.  If you put quotation marks around ‘2’, then it would be the string ‘2’, not the actual number 2.  You can’t do math on text.

Let’s look at a few examples of using PHP for math:

$num1 = 3;
$num2 = 2;<br /><br />
echo $num1 * $num2;

outputs

6

echo $num1 - $num2;

outputs

1

echo $num2 - $num1;

outputs

-1

…and so forth.

Now, we can also assign the value of whatever mathematical operation to a variable as we’re doing it.  Like so…

$total = $num1 + $num2;
echo $total;

outputs

5

Or

$total = $num1 * $num2;

outputs

6

Basically PHP will do whatever is on the right side of the equals sign first, then assign the value to the variable on the left.

Just like with Algebra, the PHP math functions do things in the ‘Order of Operations’.  So multiplication and division first, then addition and subtraction, etc.

$num1 - $num2 * $num3;

would first multiply $num2 and $num3, and subtract the result from $num1.  However, also just like with Algebra, you can also use parentheses to control what order things are done in.  So…

($num1 - $num2) * $num3;

would first subtract $num2 from $num1, and then multiply times $num3.

There is one major difference from normal Algebra in how PHP handles math.  Notice how PHP uses the equals sign to assign values to variables.  PHP does not use an equals sign like we traditionally think of it, to state equivalence.  That is,

$num1 = $num2;

Assigns the value of $num2 to $num1.  It does not say, $num1 is equal to $num2.  Or compare $num1 to $num2.  To talk about the more traditional comparison we’re expecting, we use two equals signs together.

$num1 == $num2;

This tests whether the two values are equal.  It’s a very common mistake to interchange these.