Anyone who is working on a project outside of work hours knows how tough it can be to actually get work done. There are a lot of distractions when you’re at home, lots of things you’d like to do, and it may actually be nice to take part in some relaxing activities to kind of wind down (for me, that’s video games). This is doubly true for coders with families: the kids are finally asleep, you spend a little time with the spouse, and before you know it, it’s 10pm.

Finally, you trudge into your office, sit down in front of your monitor, and open up your favorite IDE. Except, you don’t really want to. If you’re like me, you still want to kind of unwind, watch some TV or play some Xbox 360. So you throw on the TV, and before you know it, it’s 12:30am. Your night is now shot and no quality code is going to get written.

We all know the feeling. You’ve got three or four things that you’d like to do, and two or three hours to do them, but there’s a strange mental block. What should you do first? Don’t you deserve a little time to relax? Oh, and your blog hasn’t been updated in weeks! You really need to post something.

If that sounds familiar to you, let me suggest a little software product that has helped me: The Action Machine (not an affiliate link, don’t worry). The website for the product is now one of the long form sales letters, which is too bad, because the software itself is solid and straightforward. It’s actually a pretty simple idea. It let’s you create time boxed tasks and lay them out in the order you wish to complete them. There’s some videos at the website showing more of the functionality, but the simplicity kind of masks what makes this thing so great.

I’ll try to explain: Tonight, by the time the kids and the wife were asleep, I had about three hours until I would normally fall asleep. In that time I wanted to do four things:

1. Do some dev work on a project
2. Play some Modern Warfare 3
3. Write a blog post
4. Knock out some small tasks for a company I advise

Now, none of these tasks are that complex, but what order do I do them in? And there’s definitely I am going to enjoy the most which could end up sucking up my entire night if I let it (just one more round of Team Deathmatch, I swear!). So, here’s the solution:

I created time boxes for each task and activity that I wanted to complete tonight. Doing this in kind of a Work/Fun/Work order seems to be easiest for me, that first bit of work ends up going pretty quickly, since I know I only have a fixed set of time before I can do what I really want to do. The interesting thing is that, for me, this makes it much easier for me to mentally comprehend the completion of all my tasks, and shows that there is time for all of them. It also helps kind of break through that weird mental impediment that will sometimes stop people from doing anything at all.

If you work from home, or are an entrepreneur, which usually equates to an infinite number of tasks you could be working on, this is also a great tool for scheduling your next work day. One of the tasks I will frequently schedule is fifteen minutes to lay out my schedule for the next day. That way, you can simply wake up and get working.

Anyways, it’s worth a shot, it’s only $47, and some of the materials that come with it are actually kind of worth reading (at least they were when I bought it).

One thing that is frequently a pain is setting up dev servers to work on. This is especially true if you are working at home. Running a bunch of different services on your main system isn’t great as they are frequently performance hogs. Another option is to have a second piece of hardware running everything for you, but I’ve always had two issues with that:

1. It’s yet another piece of hardware driving my energy bills sky high.
2. It’s only a clean install once. Wiping the MySQL, Apache, Cassandra, <insert hot tech of the week>, install on a regular basis just isn’t something that happens.

One option I’ve utilized to avoid these issues are cloud services like Amazon’s EC2. They’re relatively easy to configure (once you get the hang of it) and depending on your usage, they may cost little more than the cost of the electricity for that second system you’re currently using. This is especially true if you’re a new AWS customer and you qualify for their Free Usage Tier. And best of all, a fresh system can be spun up rather quickly.

Getting Started

This is going to be a really brief explanation of setting up an EC2 instance. There are so many options out there that trying to cover even a tenth of, say, the Amazon Machine Images would take far too long.

After you signup for AWS, you will login to the AWS Management Console. Select EC2 from the list of services and then click the Launch Instance button. You’ll be presented with two options, Quicklaunch or Launch Classic Wizard. For this writeup, I selected the wizard. I typically start with the basic 64 bit Amazon Linux Amazon Machine Image. Select the Instance Type you need (the Mirco instance is the one that qualifies under the free tier) and the Available Zone you want and then hit Continue. Hit Continue again for the Advaned Options. For the list of keys, I’d recommend just putting a Name key in there. On the next page, create a new key pair if you need to, and make sure to save the key somewhere safe, you will need it shortly. I setup the security groups using the same configuration as this post. You can set them up now, or add them later.

You should now be able to launch the instance. After it’s started, and your security groups are setup, you should setup your SSH connection to it. You will need to utilize that key you downloaded earlier. You can utilize whatever SSH client you’re most familiar with. This is a decent writeup on how to connect if you utilize Putty like I do. In general, you will log in as ec2-user and your password will be the passphrase on your key.

Now that you’ve got your system up and running, and you can connect to it via SSH, there’s a couple of things you need to do to get Apache up and running and ready to serve some PHP. Not going to discuss these in depth really, as I would probably be the 13838th person to write this up. Here are the steps I took:

1. sudo yum update
   The system notified me that there were a number of updates available upon my first login.
2. sudo yum install httpd mod_ssl
   Install Apache.
3. sudo /etc/init.d/httpd start
   Start Apache.
4. sudo /sbin/chkconfig httpd on
   Setup Apache to start automagically upon reboot.
5. sudo /sbin/chkconfig –list httpd
   Confirm it was setup correctly
6. sudo yum install php-common php-gd php-mcrypt php-pear php-pecl-memcache php-mhash php-mysql php-xml
   Install PHP
7. sudo /etc/init.d/httpd reload
   Reload Apache.
8. sudo chown ec2-user /var/www/html
   Give the ec2-user the access it needs. Not required, but this will make your life easier later.
   

If everything went well, you should be able to go to your instance’s Public DNS entry with your web browser and see this:

Further Configuration – Elastic IP and DNS

Accessing that via an instance’s Public DNS entry isn’t the most exciting thing, and it’s not very handy. To make things easier, you may want to assign your new instance an Elastic IP. In the EC2 AWS Management Console, select Elastic IPs from under Network & Security. Click Allocate New Address and it will give you a new IP address. Now select Associate Address and select the Instance you just created. It may take up to a minute to finish the process, but once it does you should be able to enter it into your browser and see the same test page as you saw before.

This next step will vary a little bit, based on your DNS setup. The end result is that you want to create a new Address (A) record and point it at the new Elastic IP. I created a subdomain and pointed it at the new Elastic IP address, so now I can visit subdomain.example.com and it will pull up that same test page as well. Notice that after you assign the Elastic IP, your Public DNS entry will change.

The final issue to overcome is getting your files over to the server. I’m a big WinSCP user in general, so I just use that:

It’s pretty simple. Enter the hostname for your instance, ec2-user for the user, and then select the private key you used earlier. Save that session, and then login. When you login it will prompt you for the passphrase that you created earlier.

Apache will be setup to serve files from /var/www/html, but you can change that if you want by modifying the /etc/httpd/conf/httpd.conf file and restarting Apache. If you are having issues with PHP files being served properly, make sure your httpd.conf file has this line:

AddType application/x-httpd-php .php

If it doesn’t, add the line and then restart (sudo /etc/init.d/httpd restart). If you haven’t chown’d the /var/www/html directory, you’ll need to do so before you can copy files into it.

Now, you may be saying “This is no easier than just installing everything on one of my systems!”. And you’re right, the first time it is a little bit of work. But one of the great features of EC2 is that you can configure a system just the way you like it, and then save an image of that system to be reused again and again. I’ll cover that a little more in the near future, but the next time through this process should only take a couple of minutes.

AWeber is a popular choice amongst internet marketers. They’ve always had good support for things like autoresponders and easy to use signup forms that can be easily dropped into any page. A quick overview of their pricing and features:

• Free/Trial Plan: $1 / 30 Day Trial
• Basic Plan: 500 subscribers for $19 a month
• 25k Subscribers: $130 a month
• Pay as you go?: Not Available
• Analytics: Yes
• API: Yes
• A/B Testing: Yes
• Multivariate Testing: No
• SPF/DKIM support: Yes

Signing up for AWeber is straightforward enough. The trial plan gives you full access to all the functionality available with no limit on the numbers of mailings you send. Once everything is setup, AWeber greats you with a really nice Setup Wizard which walks you through setting up your first email list:

You’ll setup the basic newsletter settings, enter information about your company, setup links to social media outlets, and then tweak your confirmation message and enter a default confirmation success page. This is simply a page that the user is brought to when they agree to join your mailing list. Speaking of confirmation, the default setting in AWeber (and most ESPs out there) is to have your email lists be double opt in. Double opt in is when you signup for an email list and are first sent a confirmation email with a link that you must click before you are completely signed up. This is now optional and can be disabled, but in general you really want to keep it enabled. You will get fewer email list signups with it enabled, but you should also receive far fewer spam complaints if someone had to confirm their subscription.

After creating an email list, you are guided through creating your first email signup form:

There’s lots of easy to use preset layouts and customizing what info you ask for is pretty simple. You can also specify what Thank You page to send people to, and whether or not to enable Facebook integration. Finally, you can publish the forms or have them host the forms for you.

AWeber: Advanced

And now for the more interesting topics:

Split Testing:
With split testing, also referred to frequently as A/B testing, you are testing single-variable changes in a process. With email lists, you are frequently testing one of the following:

• Sign up forms
• Landing pages
• Email content

Ideally, the changes between your testing samples is small. A simple example would be changing the text of the Submit button on a form:

You would then run some traffic to each of these signup pages and see which one performs better. One thing you want to be certain of is to send enough traffic to provide a statistically relevant result. Sending ten visitors to each one is not enough. There are a lot of split testing calculators out there, but this is one of the easiest to use.

AWeber supports split testing two things: Web Forms and Email Content. To split test web forms, you just click the Create a New Split Test button, give the split test a name, and then specify the percentage of traffic you wish to send to each web form in the split test. Split testing your mailings is a little more complex, but they have a video covering it here.

AWeber does not support multivariate testing. Multivariate testing allows you to properly test multiple variations of multiple items. An example of this would be changing the signup button of a form to a number of different things while also testing for the best color for that button.

Analytics

AWeber provides you with lots of stats and information about your lists. Here’s a sample of some of the data they provide to you:

• List Opens Over Time
• List Clicks Over Time
• Daily New Subscribers
• Weekly New Subscribers
• Monthly New Subscribers
• Daily Subscriber Growth
• Weekly Subscriber Growth
• Monthly Subscriber Growth
• Subscribe Method
• Verified Subscribers
• Verification Times
• Countries
• State, Countries
• City, State, Countries
• Area Code

There’s  a lot more there as well, including the ability to segment your list, which is very powerful. With segmentation, you can grab the subscribers who opened your most recent message, or who clicked on a link in your message, or who live in a certain area. AWeber has a little more info here, as well as a nice example.

Sender Verification

AWeber supports all the major sender verification methods including SPF, DKIM, and SenderID. All of their email is sent from their own email addresses on the behalf of you. Emails will come from addresses @aweber.com. Some people may not like this, but it does make things a little easier. The @aweber.com email address it is sent from will be whatever you specified your email list name to be, so make sure it is something professional.

API

AWeber’s API used to be pretty bad, but it’s improved drastically, as has the AWeber Labs site containing the API information. Here’s how they describe their API:

AWeber’s API is a REST-based API that allows developers to construct their own applications for displaying and managing AWeber customer accounts. Our API uses OAuth 1.0 for authentication and returns all requested data in JSON format. Additionally, our API PHP library provides developers with a working foundation on which they can build their new applications.

There are libraries for PHP, Python, and Ruby, all of which are hosted at GitHub.

And that is AWeber.

• AWeber
• ConstantContact
• iContact
• MailChimp
• VerticalResponse

Most of these firms do fairly similar things. They have tools for gathering new subscribers, various email templates that you can modify to suit your needs, list management tools, and other marketing tools. It’s hard to say which company is the best in regards to these type of tools, as it can be fairly subjective, and the effectiveness of their offerings will vary by user. I’ll touch on a couple of the highlights for each of them, but what I’m really interested in are things that are a little more technical and more objective. The main areas of focus will be:

• Analytics – Do they offer analytics, is it easy to use, and does it provide worthwhile data?
• API functionality – Do they offer an API, is it easy to use, and does it offer good functionality?
• A/B or Multivariate Testing – Do they support A/B or multivariate testing and how simple is it to implement?
• SPF/SenderID/DKIM Support – How simple is it to setup and how helpful are they in the process?
• Mailing List Import/Export – Are you able to import and/or export your mailing list? What are the requirements when you do so?

First up will be AWeber.

The URL structure of the current site is simply http://example.com/article-or-post/, but in the updated WordPress based site there is going to be a new structure. It gets a fair amount of organic traffic, and I don’t want to lose any of that. What I wanted was a really simple way of doing 301 redirects so I don’t lose any SEO value. The easiest way to do this appears to be the Quick Page/Post Redirect Plugin.

Using the plugin is amazingly easy. Once it’s installed, you’re able to specify any URL, relative to your blog’s base URL, and redirect it to whatever destination you want, including external sites.

And that is all it takes. Just a great little free plugin that has made my life a lot simpler.

One of the things that a lot of companies overlook is outsourcing their mailing lists and transactional emails. Trying to host your own lists and send your own emails can be a very costly endeavor, especially in terms of deliverability. Most online email services are actually very affordable, and you actually get something very valuable: expertise. The companies in this sector have employees working full time to make sure they are following industry best practices, as well as helping you make sure you’re doing everything you need to be doing, including following all applicable federal laws. For a small monthly fee, you’re tapping into knowledge that is worth thousands.

There are two main types of email services:

• Mailing Lists & Email Marketing
• Transactional Emails

Mailing lists are the most popular paid service. Most of the companies in this space provide you with simple to use sign up forms, email templates, and list management and marketing tools. Monthly fees are typically charged based on how many subscribers you have, and they frequently allow you to send as many messages as you wish.

Transactional emails don’t have the visibility that mailing lists do, but they are just as important. Think of the last time you placed an order at an online store or signed up for a new website. You immediately received an email afterwards confirming that action. Another use for them is when a company needs to notify you of an important event. Your bank’s website, for instance, will notify you that your scheduled mortgage payment has been processed successfully. Or your airline’s website will notify you that your flight schedule has changed.

These are all transactional messages. They are typically one off messages that do not necessarily have any regularity and are frequently sent based on the actions of a website visitor. They are also frequently composed of information that is solely for your consumption. Services providing these type of messages usually charge by the number of messages sent.

Mailing List & Email Marketing Companies
I’m going to cover some of these a little more in depth in the near future, but here’s a quick list of some of the most popular companies that provide high quality mailing list services:

• AWeber
• ConstantContact
• iContact
• MailChimp
• VerticalResponse

Transactional Email Providers
Here are some of the leading companies in this space. These will also be covered in more depth in the near future:

• Amazon SES (beta)
• CritSend
• Dyn
• Mailjet
• SendGrid

Look for the articles covering these two areas soon. They will be linked here when they have been posted.

This post isn’t going to be breaking any new ground. I’ve been working on a project on and off for about a year now. It’s using the CodeIgniter 1.7 framework and Doctrine 1.2 for its ORM. With Doctrine, there are kind of two ways to define Models. You can create them in PHP or you can create them in YAML. I was doing the former for the longest time, but recently switched over to YAML and have been just kicking myself for not doing so sooner. Here’s an example of a model in PHP:

 * Description of field
 *
 * @property integer $order
 * @property boolean $required
 * @property ValueType $ValueType
 * @property FormField $FormField
 * @author Eric

 * @author Eric
 */
 class Field extends Doctrine_Record {

     public function setTableDefinition() {
         $this->hasColumn('field_order', 'integer', 4);
         $this->hasColumn('required', 'boolean');
         $this->hasColumn('value_type_id', 'integer');
         $this->hasColumn('form_field_id', 'integer');
     }

     public function setUp() {
         $this->hasOne('ValueType', array (
            'local' => 'value_type_id',
            'foreign' => 'id'
         ));

         $this->hasMany('LeadType as LeadTypes', array(
             'local' => 'field_id',
             'foreign' => 'lead_type_id',
             'refClass' => 'LeadTypeField'
         ));

         $this->hasOne('FormField', array (
             'local' => 'form_field_id',
             'foreign' => 'id'
         ));
     }
 }

And here’s the Field.yml file for my project:

 Field:
   tableName: field
   columns:
     id:
       type: integer(8)
       primary: true
       autoincrement: true
     field_order:
       type: int(4)
     required:
       type: boolean
   actAs:
     Timestampable:
   relations:
     FormField:
     ValueType:
     LeadType:
       foreignAlias: Fields

Now, when we run that through Doctrine_Core::generateModelsFromYaml, it will generate two files for you. An abstract BaseField class:

 /**
 * BaseField
 *
 * This class has been auto-generated by the Doctrine ORM Framework
 *
 * @property integer $id
 * @property int $field_order
 * @property boolean $required
 * @property FormField $FormField
 * @property LeadType $LeadType
 *
 * @package    ##PACKAGE##
 * @subpackage ##SUBPACKAGE##
 * @author     ##NAME## <##EMAIL##>
 * @version    SVN: $Id: Builder.php 7490 2010-03-29 19:53:27Z jwage $
 */
 abstract class BaseField extends Doctrine_Record
 {
     public function setTableDefinition()
     {
         $this->setTableName('field');
         $this->hasColumn('id', 'integer', 8, array(
              'type' => 'integer',
              'primary' => true,
              'autoincrement' => true,
              'length' => '8',
              ));
         $this->hasColumn('field_order', 'int', 4, array(
              'type' => 'int',
              'length' => '4',
              ));
         $this->hasColumn('required', 'boolean', null, array(
              'type' => 'boolean',
              ));
     }

     public function setUp()
     {
         parent::setUp();
         $this->hasOne('FormField', array(
              'local' => 'form_field_id',
              'foreign' => 'id'));

         $this->hasOne('LeadType', array(
              'local' => 'lead_type_id',
              'foreign' => 'id'));

         $timestampable0 = new Doctrine_Template_Timestampable();
         $this->actAs($timestampable0);
     }
}

and a Field class that extends the BaseField class.

Now, a couple of things to take away from this. Writing the Doctrine models by hand in PHP is a pain, where as doing so in YAML is pretty easy. Also, Doctrine creates that nice Abstract class for you, which is overwritten every time you generate the code, but also generates a simple class which extends the generated class and which is never overwritten. YAML, which stands for YAML Ain’t Markup Language, is a data serialization format and is probably closest to JSON. Using the friendly Online YAML Parser, here’s the above Field.yml file in the popular JSON format:

{
  "Field": {
    "actAs": {
      "Timestampable": null
    },
    "tableName": "field",
    "columns": {
      "field_order": {
        "type": "int(4)"
      },
      "required": {
        "type": "boolean"
      },
      "id": {
        "autoincrement": true,
        "type": "integer(8)",
        "primary": true
      }
    },
    "relations": {
      "ValueType": null,
      "LeadType": {
        "foreignAlias": "Fields"
      },
      "FormField": null
    }
  }
}

YAML skips the curly brackets (or braces, or squiggly brackets, or whatever you wish to call them), quotation marks, commas, and instead relies on spacing and indentation.

There’s another neat trick that Doctrine utilizes YAML for, and that is loading data into a database. What this is especially useful for is initializing default data into a database. Here’s a partial example, based on the Field.yml file above:

Field:
  Field_1:
    field_order: 1
     required: false
  Field_2:
    field_order: 2
     required: true
  Field_2:
    field_order: 3
     required: true

I dropped the relationships for brevity, but what the above YAML would give us are three Fields in the database, with their assigned field_orders and required values. To load that data you simply call Doctrine_Core::loadData(‘FieldData.yml’) and that is it. Read more about it here.

So you’ve got your SPF records setup nicely, you’ve used the tools available at the Postmaster sites, and your emails are being delivered, but now what? There are two things you’re concerned with now: are your emails being read and are they being reported as spam? Feedback Loops (FBLs) can’t help you with the former, but they can help you with the latter.

A Feedback Loop is pretty simple idea: when a user signifies that they believe your message to be spam, the email provider notifies you of this and sends you the message that was flagged. The only difficulty involved is that an FBL must be setup with each email providers and ISP individually, and that each FBL you setup has a different set of requirements. Typically, FBL information is listed on the Postmaster sites, so a good place to start is the list of sites that I have here.

The setup of the FBL will vary for each email provider, but here are a couple examples:

AOL
AOL has two steps to setup an FBL. The first step is to create a specific email address, fbl@. The second step is to prove ownership of the IP address in question. More info here: http://postmaster.aol.com/Postmaster.FeedbackLoop.php

Comcast
Comcast has a pretty straightforward method to signup for their FBL. You give them your contact information and the IP addresses you wish to claim. They review your information and will approve or deny your application within two weeks.
More info here: http://postmaster.comcast.net/feedback-loop.html

Yahoo
Yahoo functions a little differently. The main difference is that Yahoo requires you to sign your emails with DomainKeys or DKIM, and they also refer to the FBL as the Complaint Feedback Loop. DKIM and DomainKeys have a similar purpose to that of SPF, and I’ll most likely cover them in a post in the future. More info here: http://help.yahoo.com/l/us/yahoo/mail/postmaster/feedback/

Those are just a couple of the Feedback Loops you’ll want to setup, but they provide a quick glimpse into the different processes involved.

Some of the Postmaster sites highlighted in Part 1 contain useful troubleshooting tools. There’s too many to go through all of them, so I’ve highlighted some of the most useful ones.

AOL
AOL probably has the most extensive number of Postmaster tools of any major email provider. Among them:

• Reverse DNS Check
  Quickly verify your reverse DNS capability. You want the IP you are sending mail from to resolve to something logical. AOL has the following guidelines and recommendations for your reverse DNS entry:
• All connecting Mail Transfer Agents must have established reverse DNS
• The reverse DNS entry (PTR Record) should match the domain name (A Record)
• Reverse DNS must be in the form of a fully-qualified domain name
• Verify Connecting IP
  AOL has setup a special email address that will automatically report back to you the IP address that your email was actually sent from. This can be very helpful, especially when configuring your SPF records.
• IP Reputation Check Tool
  This tool allows you to check on the reputation your IP address (that you found using the above method). Generally, your reputation will simply be “Undisclosed”, which is fine. AOL just hasn’t received enough emails from you to form an opinion.

A complete list of the tools that AOL provides can be found here.

Time Warner Road Runner
The Road Runner Postmaster Site has a very nice IP status tool. It actually provides the results of a number of different spam block lists all in one place. With one query, you can check the status of your sending IP address from Return Path, Spamhuas, Cloudmark, and, of course, Road Runner. Here’s an example of the results for ericbrandel.com:

Comcast
Comcast has a unique tool that helps you with getting your IP address unblocked. It’s unique in that it is automated. If Comcast is the one blocking you (your block is not based on being listed as a spammer by another group) you can use their RBL Removal Form. More information is available here.

Other than the tools highlighted above, most of the providers also have a system for setting up a Feedback Loop (FBL). This is a system that alerts you when your messages are marked as spam. A post covering FBLs in a little more depth is still in the works, and will hopefully be completed in the next couple of days.

After following that tutorial, it was really this simple:

$this->load->library('rb');
$taco = R::dispense('taco');
$taco->cost = 14.95;
$taco->title = "Greatest Taco Ever";
$taco->flavor = "Tasty Fake Beef";
$id = R::store($taco);
$taco = R::load('taco', $id);
print_r($taco);

That little chunk of code loaded the RedBeanPHP library in CodeIgniter, built a completely new table in my database, inserted a new ‘taco’, and then retrieved the newly stored ‘taco’ bean and printed its guts out:

RedBean_OODBBean Object
(
    [null:RedBean_OODBBean:private] =>
    [properties:RedBean_OODBBean:private] => Array
        (
            [id] => 13
            [cost] => 14.95
            [title] => Greatest Taco Ever
            [flavor] => Tasty Fake Beef
        )

    [__info:RedBean_OODBBean:private] => Array
        (
            [type] => taco
            [sys.id] => id
            [tainted] =>
        )

    [beanHelper:RedBean_OODBBean:private] => RedBean_BeanHelperFacade Object
        (
        )

    [fetchType:RedBean_OODBBean:private] =>
)

The database table structure it created:

CREATE TABLE IF NOT EXISTS `taco` (
 `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
 `cost` double DEFAULT NULL,
 `title` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
 `flavor` varchar(255) COLLATE utf8_unicode_ci DEFAULT NULL,
 PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci AUTO_INCREMENT=1 ;

So, that’s pretty neat and it’s also the type of thing that can bring developers to tears when they think about how much time they’ve spent dealing with this part of software development. Lots and lots to explore with RedBeanPHP, but I’m already pretty impressed.