Human emotion is a fickle and misunderstood thing. A man who wins the lottery might find himself more unhappy than when he was working for $10 an hour. A paraplegic might live a more fulfilling life than somebody without any disabilities. I don’t just say this without evidence, this has been observed and studied. What, then, is the very thing that triggers a feeling of happiness instead of just general contentness? Consider this: even regular sex or a fat wallet will over time become the norm and fail to generate the happiness that it once did.

I’ve recently been thinking about an article written by Peter Norvig about mastering programming in a decade. His argument is that mastery in anything will realistically take 10 years. Naturally, I considered where I am in various fields of my interest. I have been programming for almost 10 years now. The sad part is that I’m no where near an expert. I’d consider myself an intermediate programmer. I’ve been playing saxophone on and off for about 10 years and I’m still a novice. Guitar is a hobby I started about 4 years ago.

Sadly, Norvig argues that mastery also takes consistency. Practicing everyday and pushing oneself to learn things outside of one’s comfort zone. It’s never easy to venture outside of the comfort of what you know but that’s the way we grow, right?

One last thought. It seems that if one has specific interests that one must accept that it is extremely unlikely that anyone else shares your interests, no matter how much you want them to. The socialite will focus on lowest common denominator interests to connect with people and the ‘geek’ will focus on specialised interests at the expense of being able to relate to people. I find myself constantly leaning towards the ‘geek’ side of the spectrum though I do believe there is room for a comfortable hybrid. I hope my gross over-simplification doesn’t offend anyone!

To any Comcast employees reading this post:

I’m not making any money from this site and the bandwidth usage is embarrassingly low. Take a look around my sea of spelling errors and poor sentence structure and you will not find any Google Adwords or even a clever product placement (this post brought to you by the good people at the Coca Cola Company). Perhaps, just maybe, the guy who’s about to call me to shut down my service can say, “Ya know, he’s a pretty okay guy and I’d hate to take away the one thing that makes him cool.” Seriously, this site is the only reason I have friends. By friends, I mean MySpace friends, of course.

Okay now that that’s out of the way, I want to go into some topics about the future of the Internet that I’ve been debating with myself recently.

Comcast recently announced that they will be enforcing a 250 gb/month cap on Internet usage per customer. Does this bother me? Well, yes and no. On one hand, it’s a very generous cap for the average user with a median bandwidth usage of 3 gb/month. Then again, it does go against my philosophy that the Internet(s) should be unhindered to allow for the most growth of Internet enabled applications.

What’s important to note here is that Comcast is a company with infrastructure costs and limitations. Comcast is one of the largest cable providers in the US which means that any increase in median bandwidth usage will be increasingly hard to deal with. Routers process so quickly and bandwidth is clearly limited. Even with the upcoming cap, Comcast will surely not be able to deal with every customer capping out every month. It’s really just a policy to curb the top x% of users who leave bit torrent running 24/7.

It seems obvious to me that limiting bandwidth is far better than protocol throttling alternatives which Comcast has already tried when they were throttling bit torrent traffic.

Anyway, just some random thoughts

The goal of this pattern is to separate control URLs with user displayed URLs. For example, I might have a registration URL: http://mysite.com/register. On that page is a submit button that will POST to http://mysite.com/register?action=go. Normally, after registering for a site, this second page might say “thank you for registering for mysite.com.” However, the URL /register?action=go doesn’t match the content of the page. What’s worse is that if a user hits the refresh button on the browser, most browsers will ask if they would like to re-post data which could mean multiple registration attempts.

What Post-Redirect-Get does is give the programmer much more control over how URLs are handled. A simple example on how to improve the registration page would be as follows:

1. User goes to http://mysite.com/register and fills out data, hits submit
2. The web form sends a POST request to http://mysite.com/register?action=go with the form data
3. The script does the form processing and issues a header(”Location: http://mysite.com/thankyou”) in PHP
4. When the web browser sees the ‘Location’ header, it then issues a GET request for that URL.
5. User sees http://mysite.com/thankyou.

The end result of this pattern is that a user starts at http://mysite.com/register, fills out the form, submits it, and is then brought right to http://mysite.com/thankyou. The user never sees the ugly and potentially cryptic URL of http://mysite.com/register?action=go.

To make this pattern more flexible, PHP sessions can be used to store status and error messages. Using a reserved value, like $_SESSION[’error_message’] can be set before the redirect and the display page can check if this value is set and act accordingly.

Perhaps a simple concrete example will shed more light on this design pattern. Below is the code for the registration page. Please note that this is example code and will probably not run if simply copied and pasted into a page called ‘register.php’.

<?php
session_start();
include 'db.php';
 
if ($_GET['action'] == 'go')
{
    $status = $db->query("INSERT INTO users (first, last) VALUES ('" . $_POST['first'] . "', '" . $_POST['last'] . "');");
 
    if ($status != 0)
    {
        $_SESSION['error_message'] = 'There was a database error!';
        header("Location: http://mysite.com/register");
    }
    else
    {
        $_SESSION['status_message'] = 'Registration complete!';
        header("Location: http://mysite.com/thankyou");
    }
}
 
?>
 
<html>
    <head>
    <title>Registration Page</title>
    </head>
 
    <body>
    <h1>Registration</h1>
 
    <?php if(isset($_SESSION['error_message'])): ?>
        <p>ERROR: <?=$_SESSION['error_message']?></p>
    <?php endif; ?>
 
    <form action="/register?action=go" method="post">
        <p>First Name: <input type="text" name="first" /></p>
        <p>Last Name: <input type="text" name="last" /></p>
    </form>
    </body>
</html>

And here is the ‘thank you’ page:

<?php
session_start();
?>
 
<html>
    <head>
    <title>Thanks for registering</title>
    </head>
 
    <body>
 
    <?php if(isset($_SESSION['status_message'])): ?>
        <p>NOTICE: <?=$_SESSION['status_message']?></p>
    <?php endif; ?>
 
    <p>Thank you for registering!</p>
 
    </body>
</html>

Perhaps I should back up for a second. I need to define some terminology to make this a little easier to talk about. The way he set up the geohashing algorithm creates zones on the map, which I shall call Munroe Zones. Each Munroe Zone has exactly one Munroe Point which is a statistically random point within the Munroe Zone. The zone I live in the rectangle spanning from (42.000000, -72.000000) to (43.000000, -71.000000). This spans an area of 3542.96 square miles. I will spare you the gory details of this calculation. Verify it for yourself

I can calculate the maximum distance that I can be from a Munroe Point within my zone with the cunning use of middle school geometry. The distance between (42.000000, -72.000000) and (43.000000, -72.000000) is 69 miles, approximately. The distance between one longitude measurement (42.000000, -72.000000) and (42.000000, -71.000000) is 51 miles. This means that the maximum distance one can be away from the Munroe Point in their Munroe Zone is the hypotenuse of the triangle assuming that the Munroe Point is in the far NW and I live in the far SE. This distance is about 86 miles. However, if I lived in the far SE and the Munroe Point is in the NW, that means I live directly on top of the Munroe Point for another Zone.

Because of this inter-zone relationship, the maximum distance I can be away turns into half of the maximum zone distance, or about 43 miles. The proof is pretty simple.

I thought that since Munroe Points were meant to be meeting points, one might be interested in finding the closest Munroe Point which may or may not be within the ‘zone’ they live in. I wrote a little Python script to help out.

import math, md5, struct, urllib, datetime
 
# Your coordinates!
me = [42.18719304724962, -71.5403938293457]
 
# Dow Jones Industrial Average for today
djia = float(urllib.urlopen(datetime.date.today().strftime("http://irc.peeron.com/xkcd/map/data/%Y/%m/%d")).read())
 
# Returns distance, in miles, between two coordinates
def gps_distance(gps1, gps2):
   r = 6367442.5 * 0.000621371192 # earth radius, miles.
   dLat = math.radians(gps1[0]-gps2[0])
   dLon = math.radians(gps1[1]-gps2[1])
   x = math.sin(dLat / 2) ** 2 + math.cos(math.radians(gps1[0])) * math.cos(math.radians(gps2[0])) * math.sin(dLon / 2) ** 2
   y = 2 * math.atan2(math.sqrt(x), math.sqrt(1-x))
   d = r * y
   return d
 
# Determines if coord is NW, SW, NE, or SE relative to my_munroe_point
def position(coord, my_munroe_point):
   ns = 'N' if coord[0] > my_munroe_point[0] else 'S'
   ew = 'E' if coord[1] > my_munroe_point[1] else 'W'
   return ns + ew
 
# Determines the Munroe point within your zone, as the comic does.
def my_zone_munroe_point(coord):
    day = datetime.date.today().strftime("%Y-%m-%d")
    munroe_coord = [0,0]
    md5_hash = md5.new("%s-%5.2f" % (day, djia)).hexdigest()
    adjust = [long(md5_hash[:16], 16) / 2.**64, 
              long(md5_hash[16:], 16) / 2.**64]
    munroe_coord[0] = math.floor(coord[0]) + adjust[0] if coord[0] > 0 else math.ceil(coord[0]) - adjust[0]
    munroe_coord[1] = math.floor(coord[1]) + adjust[1] if coord[1] > 0 else math.ceil(coord[1]) - adjust[1]
    return munroe_coord
 
# Calculates the nearest Munroe Point, which may or may not be the one
# in your zone.
def nearest_munroe_point(coord):
    my_munroe = my_zone_munroe_point(coord)
    pos = position(coord, my_munroe)
    points = []
 
    if (pos == 'NW'):
        points.append(my_zone_munroe_point([coord[0] + 1, coord[1] - 1]))
        points.append(my_zone_munroe_point([coord[0] + 1, coord[1]])) 
        points.append(my_zone_munroe_point([coord[0], coord[1] - 1])) 
    elif (pos == 'SW'):
        points.append(my_zone_munroe_point([coord[0] - 1, coord[1] - 1]))
        points.append(my_zone_munroe_point([coord[0] - 1, coord[1]])) 
        points.append(my_zone_munroe_point([coord[0], coord[1] - 1]))
    elif (pos == 'NE'):
        points.append(my_zone_munroe_point([coord[0] + 1, coord[1] + 1]))
        points.append(my_zone_munroe_point([coord[0] + 1, coord[1]])) 
        points.append(my_zone_munroe_point([coord[0], coord[1] + 1]))
    elif (pos == 'SE'):
        points.append(my_zone_munroe_point([coord[0] - 1, coord[1] + 1]))
        points.append(my_zone_munroe_point([coord[0] - 1, coord[1]])) 
        points.append(my_zone_munroe_point([coord[0], coord[1] + 1]))
 
    dis = gps_distance(coord, my_munroe)
    nearest = my_munroe
 
    for point in points:
        tmp = gps_distance(coord, point)
        if (tmp < dis):
            nearest = point
            dis = tmp
 
    return nearest
 
my_munroe = my_zone_munroe_point(me)
my_munroe_dis = gps_distance(me, my_munroe)
nearest_munroe = nearest_munroe_point(me)
nearest_munroe_dis = gps_distance(me, nearest_munroe)
 
print "Munroe Point coordinates  (my zone):", my_munroe
print "Distance to my Munroe Point (my zone):", round(my_munroe_dis, 2), "miles"
print "Nearest Munroe Point coordinates:", nearest_munroe
print "Distance to nearest Munroe Point:", round(nearest_munroe_dis, 2), "miles"

The output I got when I ran this for today’s data is as follows:

Munroe Point coordinates (my zone): [42.179467994697781, -71.86153601245762]
Distance to my Munroe Point (my zone): 42.77 miles
Nearest Munroe Point coordinates: [42.179467994697781, -70.86153601245762]
Distance to nearest Munroe Point: 14.94 miles

Below I have provided some example code that I compiled with GCC 3.4.6. The point of this program is to show how static memory allocation works. Try to execute the code in your head before compiling it and running it.

#include <stdio.h>
#include <string.h>
 
int main (int argc, char * argv[])
{
  char * numbers = "1234567890";
  char * letters = "abcdefghij";
  char * a;
  char * b;
  char * c;
  char tmp;
 
  if (strcmp(letters, "abcd") == 0)
    {
      printf("This should not print although we will use it later!\n");
    }
 
  /* 
     TEST 1:
 
     Print address of numbers and letters the addresses
     should be 11 bytes apart.
  */
  printf("numbers: %p\n", numbers);
  printf("letters: %p\n", letters);
  printf("diff:    %d bytes\n", (letters - numbers));
 
  /* 
     TEST 2:
 
     A and B should be the same address because they
     reference the same static value 
  */
 
  a = "1234567890";
  b = numbers;
 
  printf("a:       %p\n", a);
  printf("b:       %p\n", a);
 
 
  /* 
     EXERCISE 1:
 
     Take a moment to look at the following code
     and figure out what will be printed to the
     screen
  */
 
  c = "abcd";
 
  for(a = numbers; a < c + 5; a++)
    {
      /* get the character that 'a' points to */
      tmp = a[0];
 
      switch (tmp)
        {
        case '\0':
          printf("\\0");
          break;
        case '\n':
          printf("\\n");
          break;
        case '\r':
          printf("\\r");
          break;
        default:
          printf("%c", tmp);
          break;
        }
    }
 
  printf("\n");
 
  return 0;
}

The key to understanding this is that each variable in double quotes is put into a ’static’ section of the compiled binary in the order which they were declared. The loop that I write iterates over the first three static variables and prints them out highlighting the null terminating character \0. It’s important to note that the compiler tightly packs each static value separating each string only by a null terminating \0 character. The point of this static data section is that it will be immutable.

As an exercise, Try changing the c + 5 in the for loop to c + 10 and guess what the next 4 characters will be.

On unix-like systems, attempting to write to this static section will result in segmentation faults. For example, if I try to do numbers[0] = ‘@’, I should get a segmentation fault. However, one could copy ‘numbers’ into a variable pointing to the heap or stack and perform this operation just fine.

I arrived at 5:50, 10 minutes before the opening. To no surprise, there were hundreds of people crowded around the entrance and across the street. I was in the back of the crowd trying to get a glimpse of the fuss. Every news van in the area was there as they got early entrance into the store for interviews and story coverage. It was really quite a spectacle.

Let me talk about the actual building for a second. Sandwiched between two classic old-Boston style buildings, Apple has erected a post-modern looking all glass building. The three story marvel is basically right across the street from the Hynes Convention Center in what Apple called a prime location. This store is the largest in the nation, to no surprise. The giant Apple logo itself hangs from the third floor standing 8 feet tall. I like the building, it seems to add a nice feeling to the area. Then again, I’ve never been attached to traditional Boston architecture.

At 6:00, cheers started erupting as the doors opened and I noticed that there actually was a line that had formed that headed down to the corner of Boylston and Fairfield. As I saw the people start to filter in, I decided that I should probably get in line too. I headed towards the corner to realize, to no surprise, that the line wrapped around down Fairfield. What I didn’t expect was how long it was. Apple blocked off an entire lane of the road and the line extended, tightly packed, all the way down to Commonwealth Avenue.

I figured that I came this far already so I might as well wait. Well, two difficult sudoku puzzles and an hour later, I arrived back at the entrance to the sound of cheering. They had about 20 employees who’s job was simply to cheer as people entered the building and hand out shirts and give high fives. After receiving an XL shirt (why can’t they give out mediums?!) and about 30 high-fives, I was in. The only way to describe it is as an orgy of fanboys drooling over absolutely everything. There must have been twenty employees per floor and each went out of their way to say hi and try to make shopping a good experience. Overall, it was a good time. Would I go to another grand opening? Probably not. I’m not enough of a fanboy for this sort of thing

Only Apple can make a grand opening of a computer store like going to an exclusive nightclub. It’s amazing that they managed to turn tech support into marketing. The entire third floor of the Boylston St. Apple Store is a genius bar, training, and tech support. It’s also amazing that Apple has turned their retail stores into a ‘cool’ place to hang out. People young and old from all demographics showed up just to hang out. I don’t know how they did it, but it certainly made for a good experience.

For anyone who’s programmed PHP, a URL like this is not uncommon: http://localhost/blog/index.php?page=photo&name=a-sunset-on-the-beach. It’s gross, unreadable, and for a non-programmer the parsing of the URL stops at the question mark. A URL is supposed to point, unambiguously, to a resource and that paradigm should not be broken when making pretty URLs. However, there does not need to be complete transparency from the resource indicator that the user sees to the resource that’s actually on the server. Consistency is important though. A URL should not ever go out of date and if it does change, proper redirections should be in place to aid users using older URLs.

Commonly, Apache’s mod_rewrite module is used to translate a pretty URL to an ugly one. For example, one might translate /blog/photo/a-sunset-on-the-beach to /blog/index.php?page=photo&name=a-sunset-on-the-beach. I agree that this is great for user experience but I do not think this is an optimal solution.

Why should we bother translating to a nasty URL when the nice URL comes to the server? Why not just pass PHP the nice URL and parse it as such. One could define a standardized structure for the URL:

/[base directory]/[category]/[item]

This URL would then be passed and parsed by PHP and the necessary PHP files would be included conditionally based on the [category] and [item] values.

Obviously, this approach requires a single point of entry into your PHP application where you parse the URL and dispatch to other PHP files as necessary. The first thing that needs to be done to get this working is to tell apache to pass the URL as is to PHP via an .htaccess file:

Options +FollowSymLinks
IndexIgnore */*
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule . index.php

Within PHP, we need to define our base URL and then parse the incoming URL. Below is a sample index.php file which resides in the same directory as the .htaccess file created above:

<?php
 
// Tells that our base is /blog
$base_directory = array_filter(explode('/', '/blog'));
 
// Produces an array of our request vars.
$request_url = explode('/', $_SERVER['REQUEST_URI']);
 
// Remove the base directory from the request URL
$request = array();
$count = 0;
 
foreach ($request_url as $elem)
{
  if (array_search($elem, $base_directory) === FALSE)
  {
    $request[$count++] =  $elem;
  }
}
 
// Call the necessary controller object
include $request[0] . ".php";
 
?>

If we had passed the URL http://localhost/blog/photo/a-sunset-on-the-beach, we’d end up getting a $request variable that looked like this: array(0 => 'photo', 1 => 'a-sunset-on-the-beach'). The bottom line, which includes the file, is basically a controller which will use the $request array to generate what is needed and display the correct template to the browser.

I like this approach because it provides a write-once approach to URLs and allows the programmer to not think in terms of standard GET variables and start with a clean slate of pretty URLs. This example is quite rudimentary and to the point, which is why I recommend making this more robust before deploying it on a real site.

I bring this up because Leo Laporte recently commented on an application called Pukka, priced at $15. He had many great things to say about it and how he used it everyday, but claimed that this application ’should be free.’ It’s one thing to say that the software sucks and it should be free, but to say that it’s a quality product and should be free? Ridiculous. Just because I’d like it if cars were free, doesn’t mean that they should be free. We’ve all been somewhat spoiled by free software. VLC, Firefox, and many other software bundles are taken for granted by everybody. Would we say that Firefox ’should be free’? If so, WHY should it be free? Is it because software should be the right of everybody? Don’t get me wrong here, the Free Software Foundation is doing good things and I quite like the fact that there is free and open source software, but we must realize that this software is charity, usually done with another capitalistic motive in mind.

If we agree that intellectual property has value, we should concede that software has value. In fact, I KNOW software has value because I, like so many others, have a job in software engineering. Software is the only field, anywhere, where consumers expect a free lunch. People don’t seem to know that software actually takes time and energy. This stuff doesn’t just appear from nowhere. A good application isn’t written in 2 hours in some guys basement while watching America’s Next Dance Crew. Real time, energy, and expertise are needed to create good software. Software engineers and hobbyist programmers are among the worst culprits of software oversimplification. It’s amazing how people can reduce complex programs to simple one line statements: “Oh, it just displays text and highlights the syntax, what’s the big deal? That’s not worth 20 euros.” This line of reasoning is used to improperly justify piracy. If one can convince themselves that the software in question is simple enough to have been written by themselves, then they are allowed to pirate it. My challenge to people who say that is to actually try to write the software in question. For that matter, try writing any full featured piece of software that another person might consider using. It’s not nearly as simple as you think.

We must debunk this notion that those who charge for software are evil. I’m guessing there are a lot of people who think that those charging for software they write are just scamming us and are being greedy. Instead, let’s look at this in a different light. An engineer who charges a modest fee for a software license actually does want to bring us quality software. Quality software needs funding. Without corporate funding, an independent developer must rely on direct payments. It’s not all bad. Some of these people might actually be nice.

What else bothers me is when people say, “There’s no way that’s worth $15, I’d pay $5, maximum.” Well, that’s all well and good, if you choose not to buy the software. However, if you complain about it being way too expensive and then pirate it, you’re admitting that this software is worth enough to use it but not worth enough for you to pay for it. This is a direct parallel to stealing a bike from a bike shop on weekends because the full value of the bike is too much but you still want the benefit of riding the bike at your convenience. In the end, the bike shop still has the bike to sell, because you didn’t steal it and they’re getting no profit from you. Imagine if everybody used the bike shop like a rental store which they didn’t pay for.

The problem is that if you steal software, you ARE taking away income. The argument “Well, I wouldn’t buy it anyway so it’s okay to steal it,” is a logical fallacy. Imagine if I made this claim: “Well, I wouldn’t watch any TV or movies, use any internet access, use any proprietary software, use electricity, or pay for trash removal if I had to buy it, so it’s okay for me to steal all of those things from my neighbor.” The argument falls apart. Even worse: “I wouldn’t buy anything therefore I should be able to steal everything.” If you really wouldn’t use this product if you had to pay for it, then don’t use it.

My main point is that we should be sympathetic towards independent developers and not immediately assume that we’re being ripped off by having to buy software. I also would hope that we can at least see piracy from independent developers as hurting them and hurting independent software in general. Free software may be great but let’s think of this as an exception to the rule rather than the rule!

In terms of abstraction, this makes perfect sense. Represent all real-life things as simple objects with modifiable attributes that correspond to column names in the database. My approach to ActiveRecords in PHP started with an abstract class:

<?php
abstract class ActiveRecord
{
	protected $exists;
	protected $is_changed;
 
	// Every entry has an ID
	private $id;
 
	public function __construct()
	{
		$this->exists = false;
		$this->is_changed = true;
	}
 
	public function __get($var) {return $this->$var;}
 
	public function __isset($var)
	{
		if ($var == 'exists' || $var == 'is_changed') return;	
		return isset($this->$var);
	}
 
	public function __unset($var)
	{
		if ($var == 'exists' || $var == 'is_changed')return;	
		unset($this->$var);
	}
 
	abstract public function __set($var, $val);
	abstract public function load($id);
	abstract public function save();
	abstract public function delete();
	abstract public static function find(TableFilter $filter);
}
?>

From this base class, I can create a new class that extends ActiveRecord. The first thing I’d have to do is implement __set, load, save, delete, and find. The point of these functions is to do the correct database queries to get the data into the private members of the function, modify the fields as necessary (with validation) and then save the state of the object to the database.

The variables $exists and $is_changed help with determining how the object matches the data in the database. For example, upon doing a load(), $exists is true and $is_changed is false. Doing a delete puts $exists to false. Here’s a sample of an object that would extend ActiveRecord.

<?php
class Product extends ActiveRecord
{
	// Foreign Keys
	private $department_id;
 
	// Attributes
	private $name;
	private $in_stock;
	private $description;
	private $price;
 
	public function __set($var, $val)
	{
		switch ($var)
		{
			case 'name':
			case 'description':
				$this->$var = $db->sanitize($val);
				break;
			case 'price':
				if ( !is_currency($price) )
					throw new Exception("price is not a valid value");
				$this->$var = $val;
				break;
			case 'in_stock':
				if ( $val != 1 && $val != 0)
					throw new Exception("not a boolean");
				$this->$var = $this->$val == 1 ? true : false;
				break;
		}
 
		$this->is_changed = true;
	}
 
	public function load($id)
	{
		global $db;
		$row = $db->queryRow("SELECT * FROM products P WHERE p.id='$id';");
		if (!$row) throw new Exception("does not exist");
		$this->is_changed = false;
		$this->exists= true;
	}
 
	public function save()
	{
		global $db;
 
		if ($this->exists == false)
			$return = $db->query(".... do an INSERT query ....");
		else
			$return = $db->query(".... do an UPDATE query ....");
 
		if ($return == false) throw new Exception("save failed");
		$this->is_changed = false;
		$this->exists= true;
	}
 
	public function delete()
	{
		global $db;
		$row = $db->queryRow("DELETE FROM products P WHERE p.id='$id';");
		$this->is_changed = true;
		$this->exists= false;
	}
 
	public static function find(TableFilter $filter)
	{
		// This is where you do a custom query
	}
}
 
?>

Obviously, this code is just for an example and likely needs to be tweaked to work in an actual environment. The code I use is pretty close to this, with a little bit more robustness in the error checking.

I find that this approach starts to converge to an MVC type of design where the ActiveRecord very clearly represents the model aspect of things. If I were to program a Product Controller, the controller might instantiate new Product objects, alter the data within, and save it back without ever seeing an SQL statement. In fact, most controller actions might never be more than 15 lines of code, which certainly seems the best way to get interactions between the user’s web browser and the database as efficiently as possible