What is an LLC?

A limited liability company or a company with limited liability (abbreviated L.L.C. or LLC or W.L.L) in the law of the vast majority of United States jurisdictions is a legal form of business company that provides limited liability to its owners. Often incorrectly called a “limited liability corporation” (instead of company), it is a hybrid business entity having certain characteristics of both a corporation and a partnership or sole proprietorship (depending on how many owners there are). An LLC, although a business entity, is a type of unincorporated association and is not a corporation. The primary characteristic an LLC shares with a corporation is limited liability, and the primary characteristic it shares with a partnership is the availability of pass-through income taxation. It is often more flexible than a corporation and it is well-suited for companies with a single owner.

Delaware LLC is built on our custom Drupal CMS package. It was designed from the ground up by Creative Director Kevin Howett, and put together in a collaborative effort between newcomer Matt Oseland, Kevin Howett and Bryan Cordrey. Efforts were focused on a pleasing, business-minded design, effective search engine optimization, and funneling/encouraging customers to begin the process of forming an LLC in Delaware.

As Rick’s customers go to him and Harvard Business Services for their LLC/incorporation expertise, Rick came to Inclind for our expertise in clean, effective websites and powerful web application development under Drupal and our deep knowledge of content management systems such as Drupal. We also got to flex our system integration skills with Drupal, PHP and Coldfusion.

About Delaware LLC & Harvard Business Services

With more than 25 years of experience, over 20,000 clients worldwide, and offices in both the United States and Europe, Harvard Business Services, Inc. is the premier provider of registered agent and business formation solutions.

Rick Bell formed Harvard Business Services, Inc. in March, 1981. Competitors then were big and well established. But Rick conducted business with a philosophy that allowed Harvard not just to survive but to thrive, emerging over time to become an acknowledged leader in the business formation industry.

His philosophy focused on a highly personalized style of customer service, understanding that beyond the mechanics of forming a business there were dreams and aspirations. A customer’s individual questions and concerns were important and special, and that’s how they were treated.

Rick also decided that a customer’s business formation costs should be fixed, predictable, affordable, and customers should get a lot of value for their money.

After almost 30 years and tens of thousands of business formations later, that same approach is still the signature of our culture and way of doing business: speed, efficiency, expertise and affordability, all delivered with the Harvard legacy of personal service.

Headquartered in Lewes, DE, Harvard Business Services, Inc. today is the leading provider of business formation services. Along with the Harvard Business Services brand of fast, personalized service, customers soon discover a number of other traits that set Harvard Business Services, Inc. far apart from the rest.
———————————————–

If you have any questions regarding content management systems, Drupal, Coldfusion or systems integration, we are here to help. Give us a call at 302-856-2802, send us a tweet @inclindinc, or stop by our office. We have been the leading web development firm in the area for over 10 years running and have fourty years of combined web experience under one roof.

Lets take a look at how you bring in files as part of that node as well. From the previous example, before calling node_save($node), I call another function to process files. Name it however you wish. My module is called homes_sync, so my hooks and functions begin with that as per Drupal standards.

1
2
3

homes_sync_get_files($node, $nid, $sessid);
// save the node object
node_save($node);

homes_sync_get_files() is passed the $node object and will return it after adding (or removing) data. To have a reliable file sync, we need to only update files if they are newer, and remove them if they no longer exist.

In this specific example, the project I am working on has two CCK file fields. One is for a floorplan (a PDF) and the other is an image field. In a node, there is only 1 floorplan, but can be up to 2 dozen images. If you had a more generic node that just has a CCK filefield of ‘client_files’ for example, your code would be slightly different.

Before we add any files to the node, the first thing we should do is compare the list of files from the remote site to the local site. We start that off by getting $files via xmlrpc, and loading the node object if $node->nid is present. If any are found on the local site, and not the remote site, we can safely remove them from the node object. The two arrays are iterated over and remove files if necessary.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

function homes_sync_get_files($node, $nid, $sessid) {
 
	$files = xmlrpc(REMOTE_SERVICES_URL, 'file.getHomeFiles', $sessid, $nid);
 
	// first, compare list of files from parent server with local files
	// if our local files has something the parent server doesnt have
	// it was probably deleted. so we need to unset it from the node object
	// when it gets passed back through node_save, cck should delete it proper
 
	if ($node->nid) {
 
		$current_files = node_load($node->nid);
 
		if ($current_files && !$files) {
			// we have files locally, but none on the parent server. 	
			// remove all
			unset($node->field_floorplan);
			unset($node->field_image);
			watchdog('homes_sync', 'Remote copy of @node no longer has files. Removing all local files for @node.', array('@node' => $node->title), WATCHDOG_NOTICE);
		} elseif ($current_files && $files) {
 
			// build comparison arrays
 
			foreach ($files as $remote_file) {
				$remote_files[] = $remote_file['filename'];	
			}
 
			foreach ($current_files->field_floorplan as $local_floorplan_file) {
				$local_files[] = $local_floorplan_file['filename'];
			}
 
			foreach ($current_files->field_image as $local_image_file) {
				$local_files[] = $local_image_file['filename'];
			}
 
			// now lets see whats missing
 
			if (is_array($local_files) && is_array($remote_files)) {
 
				foreach ($local_files as $local_file) {
					if (!in_array($local_file, $remote_files)) {
						// parent site does not have this file in the node anymore
						$files_to_delete[] = $local_file;
					}
				}
 
				if (!empty($files_to_delete) && is_array($files_to_delete)) {
					foreach ($files_to_delete as $key => $file_to_delete) {
						// CCK field arrays exist in node objects even if they have no data
						// we can assume if the first record is NULL, there is no data
 
						if ($node->field_floorplan[0] != NULL) {
							foreach ($node->field_floorplan as $file_key => $floorplan) {
								if ($file_to_delete == $floorplan['filename']) {
									watchdog('homes_sync', '@file file does not exist on parent server anymore for @node. Removing.', array('@file' => $floorplan['filename'], '@node' => $node->title), WATCHDOG_NOTICE);
									unset($node->field_floorplan[$file_key]);
								}
							}
						}
 
						if ($node->field_image[0] != NULL) {
							foreach ($node->field_image as $image_key => $image) {
								if ($file_to_delete == $image['filename']) {
									watchdog('homes_sync', '@image image does not exist on parent server anymore for @node. Removing.', array('@image' => $image['filename'], '@node' => $node->title), WATCHDOG_NOTICE);
									unset($node->field_image[$image_key]);
								}
							}
						}
						unset($floorplan);
						unset($image);
					}
				}
 
			}
		}
 
		unset($remote_files);
		unset($local_files);
	}

Now that we are through with our deletion process, we can begin processing the remote files. For each file id ($fid) we call xmlrpc and get all the data and the file itself and bring it down to our local site. Based on the file extension, we begin building a query so we can look to see if this file exists locally, and what its last timestamp was. We do this so we know if a file should be replaced or not. For example, if you have MyHome.PDF on your local site, and a new version is uploaded on the remote site, simply comparing file names is not good enough. With a filename and a timestamp comparison, you are certain that it should be processed.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

	if ($files) {
 
		foreach ($files as $fid => $remote_file) {
			$file = xmlrpc(REMOTE_SERVICES_URL, 'file.get', $sessid, $fid);
 
			if ($file) {
				// set filepath to save to
				// decode our content file
 
				$file['filepath'] = file_directory_path().'/'.$file['filename'];
				$file_data = base64_decode($file['file']);
 
				// set content type db table, and field to search on.
				// Load up the CCK field
 
				$filetype = explode('.', $file['filename']);
 
				if ($filetype[1] == 'pdf') {
					$content_table = 'content_type_homes';
					$fid_field = 'field_floorplan_fid';
				} else {
					$content_table = 'content_field_image';
					$fid_field = 'field_image_fid';
				}
 
				$file_details = array();
 
				// check if it's the same file coming over
				// only applies if the node exists in the first place. otherwise its a new import on a new home
				// if there is a file match we dont want to do anything but skip the creation
				// i think if you dont keep the node->file field prefilled, and returns those fields empty, it causes the file deletion on the server
 
				if ($node->nid) {
 
					$result = db_query("SELECT f.filename, f.fid, f.filepath, f.timestamp FROM {files} f
											INNER JOIN {%s} ctype ON f.fid = ctype.%s
										WHERE f.filename = '%s'", $content_table, $fid_field, $file['filename']);
 
 
 
					$file_details = db_fetch_array($result);
 
				}
 
 
 
				if ($file_details && $file_details['timestamp'] < $file['timestamp']) {
 
					// if file exists and has not changed remotely, skip it
 
					watchdog('homes_sync', '@file already exists for @home. Skipping.', array('@file' => $file_details['filename'], '@home' => $node->title), WATCHDOG_NOTICE);
 
				} else { 
 
					// save file
					// REPLACE because we can be certain we will not have duplicate files
					// so we will only ever receive unique ones here
 
					file_save_data($file_data, $file['filepath'], FILE_EXISTS_REPLACE);
 
					//write record in files table
					drupal_write_record('files', $file);
 
					$result = db_query("SELECT fid,filepath FROM {files} WHERE filename = '%s'", $file['filename']);
					$file_details = db_fetch_object($result);
 
					$file_data = field_file_load($file_details->fid);
 
					watchdog('homes_sync', 'Uploaded @file into @home.', array('@file' => $full_file['filename'], '@home' => $node->title), WATCHDOG_NOTICE);
 
					if ($file_data) {
 
						if ($filetype[1] == 'pdf') {
							$node->field_floorplan[] = $file_data;
						} else {
							$node->field_image[] = $file_data;
						}
 
					}
 
				}
 
 
			}
		}
	}
 
	return $node;
}

After the file is saved to the file system and database, field_file_load() is called to load the file data. With a populated array now, we can add that to our node object by simply putting $node->field_floorplan[] = $file_data or $node->field_image[] = $file_data to append the existing array with data. The $node object is returned, and node_save($node) is immediately called, and our node data and file data are saved. Just like that, we have a simple content distribution system from one parent site to potentially many remote sites.

This is just a simple example, your mileage may vary. We are utilizing this technology to hook companies together under different Drupal installations on different servers. Using Services you could also distribute Views configurations, users, and system settings.

Up to that point, we had done every project in Coldfusion hosted on Windows (and eventually Linux). There is a price tag that came with that though, whether it be hosting, Coldfusion licensing/upgrading, or development costs. As people were let go due to the economy, we also realized that it is difficult to support proprietary code for a proprietary solution someone else wrote. Why? Because that person is the only person in the world who knows why they made the application/code that way. When something goes wrong, you spend hours trying to find the issue, and even more time coming up with a tested reliable solution.

Proprietary solutions are sold as the best thing since sliced bread, but what customers don’t know is that they are getting locked in to that company. You can’t easily cut ties with a firm and take your site someplace else. Proprietary applications are the brainchild of whoever developed it. Therefore, when you need support, you won’t get it. That developer is long gone, but you are stuck with their code. These firms put you in a box and want to keep you there- that is the whole point of proprietary systems. Why do you think you can’t install OSX on a PC? Why do you think video games are built only for Windows, and not Linux or Mac? It’s all about client retention.

With that, we decided to start fresh and drop our proprietary Coldfusion CMS and Ecommerce platforms. Everyday we were tied up in fixing Inclind Commerce, or trying to meet the needs of each client for Inclind CMS. Pete and I went as fast as we could, but we pretty much knew there was no way to compete with the rest of the world. We turned to open source solutions to provide us a solid base to build off of, instead of starting each project from scratch (which all essentially had the same core functionality as it were). Developing Coldfusion in Fusebox framework is/was an absolute nightmare and probably still is. It is a disjointed unauthentic implementation of MVC style framework despite what they say, and requires you to hold its hand every step of the development process.

We knew Wordpress would not be a solution at all. At best, it is a blogging platform and nothing more. You may read lots of articles that say how awesome Wordpress is and is a CMS, but it is not a CMS. You’ll also see that those articles are written by designers too, not developers. It’s a pain in the ass to develop for, it has patches every other week, plugins are prone to XSS attacks or theme hacking, and cannot sustain the level of development we perform. It is not a prime-time application for websites.

We also tried Joomla. Knowing it was based around Mambo, my expectations were low for it based on the experience I had working with Mambo. Even 5 years later, it had an ugly backend, scattered developer community, and little support. The developer area is full of confusing rules, practices and jargon. Take this for example, from the Joomla extensions page:

• Component – Mini-application to render the main page body.
• Module – Renders small html blocks on any page.
• Plugin – Changes code behavior dynamically.
• Language – Provides language translation.
• Ext. Specific Addon – Specific addon that requires another ext. to operate.
• Tool – External application that helps with creating or managing Joomla! site.

What the hell is the difference? All 6 bullet points say the same thing, yet they are 6 different kinds of extensions for Joomla. We couldn’t see ourselves training clients around the confusing backend or having lowered development time with their overly complicated extension system and scary licensing rules.

We came to Drupal. I had heard about this one on and off in various circles, generally more good than bad. After a week of successful proof of concepts for different kinds of websites, we decided Drupal was the best solution for us in terms of what we needed to accomplish.

Out of the box, Drupal provides:

• Database abstraction
• Auto-discovery of custom modules
• Managed workflow
• Robust Development API
• Experienced and organized developer community
• Intuitive administrative backend
• Easy integration of custom modules through the hook system

There is a solution for just about any scenario in the Drupal world. They have a very good approval process for modules. For example, if a module has security loopholes or bad coding practices, it will not be accepted until those are corrected (I don’t see this happening in other projects). If someone is trying to submit a module that already exists in some form, they are encouraged to merge efforts so the community isn’t littered with duplicate modules with the same functionality. It is differences like these that make Drupal the most widely used, highly regarded, best open source CMS bar none.

Our choice was the right one, proving vital in our relevance to custom web development and is a reason why we are still here and still the top choice for web design / web development / website building on the peninsula. We are able to deploy websites with a consistent codebase and backend in rapid succession. Clients are pleased with the added functionality and easier administrative UI. We’re at the point now where we can take Drupal and make it do anything we need it to do, big or small. We’ve been able to provide scalable solutions from the collaboration of many people providing a solid product. Instead of a couple of people making an in-house solution, we’re working with hundreds on a more polished result. We changed our entire development process so we could have a streamlined workflow and tighter communication between ourselves and the client with great results.

We have some pretty cool projects in the pipeline for 2010 utilizing Drupal and hope to have some things to show off in the next few months. iPhones, region-free real estate integration, content distribution, big boy stuff. Lookout.

There are some ‘gotchas’ though if you develop custom Drupal modules like we do. During the install process, Drupal only bootstraps the bare minimum to get the job done. I’ve noticed that if a module’s install routine calls functions outside of the .install file, the expected result tends to fail because files other than .install are not included during this loading process. It seems there is a special case for the file to be included, or you have to specify in your install profile to explicitly include the file (which takes a lot of time to do). To be specific, I have seen this happen with Drupal Boost, Drupal Gallery Assist, and our custom module Billboard, which tipped me off to this problem. The issue has since been fixed in Boost (and Billboard).

For us, the issue was creating custom ImageCache presets during a module’s install routine. This worked perfectly if you were going to the Drupal Modules page and enabling Billboard. What happens was the hook_install() function fired, included a definition file, and created presets based on that file. This fails during a Drupal install profile, where you use a script to install and configure Drupal automatically. This same issue occurs in Gallery Assist, and here is how I got around it:

It was pretty apparent that the code needed to come out of the install function. However, I needed to be sure that where I put the code would be compatible to the module loading process, and I’d need to be sure ImageCache was both installed and loaded before running the following code. Otherwise it would error out, and no ImageCache presets would be created.

Drupal has a crucial hook for modules. hook_init() allows you to perform tasks every time the module is loaded. In this case, I wanted to tell it to run a function and check for two default ImageCache presets. If they didn’t exist, create them. This approach solves three issues:

1. Getting around install profile limitations
2. Provide default ImageCache presets for Billboard module when it is enabled
3. Recreate the ImageCache presets if they are accidentally deleted by the user (or developer )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

<?php
 
function mymodule_init() {
    mymodule_create_default_imagecache_presets();
}
 
function mymodule_create_default_imagecache_presets() {
 
    $default_size = imagecache_preset_by_name('mymodule-default');
    $thumb_size = imagecache_preset_by_name('mymodule-thumb');
 
    if (count($default_size) == 0 || count($thumb_size) == 0) {
        if (count($default_size) == 0) { 
            $mymodule_default_size = "600";
            $mymodule_thumbnail_size = "80";
 
            $presets = array();
 
            // Default size.
            $presets['default'] = array (
            'presetname' => 'mymodule-default',
            'actions' => array (
 
                  'weight' => '0',
                  'module' => 'mymodule',
                  'action' => 'imagecache_scale',
                  'data' => array (
                    'width' => $mymodule_default_size,
                    'height' => '',
                    'upscale' => 0,
                  ),
 
              ),
            );
 
            imagecache_preset_save($presets['default']);
            $presets['default']['actions']['presetid'] = db_last_insert_id('imagecache_preset', 'presetid');
            imagecache_action_save($presets['default']['actions']);
            imagecache_preset_flush($presets['default']);
            imagecache_presets(TRUE);
 
        }
 
        if (count($default_size) == 0) { 
            $presets['thumb'] = array (
            'presetname' => 'mymodule-thumb',
            'actions' => array (
 
                  'weight' => '0',
                  'module' => 'mymodule',
                  'action' => 'imagecache_resize',
                  'data' => 
                    array (
                      'width' => $mymodule_thumbnail_size,
                      'height' => $mymodule_thumbnail_size,
                      'upscale' => 0,
                  ),
 
              ),
            );
 
            imagecache_preset_save($presets['thumb']);
            $presets['thumb']['actions']['presetid'] = db_last_insert_id('imagecache_preset', 'presetid');
            imagecache_action_save($presets['thumb']['actions']);
            imagecache_preset_flush($presets['thumb']);
            imagecache_presets(TRUE);
 
        }
    }
 
    return;
}
?>

What that says basically is ‘hey, do our default ImageCache presets exist?’ if not, it will create them at runtime.

I have tested this a handful of times with positive results, and, it works with install profiles since hook_init() is called after Drupal loads. Food for thought for all you Drupal developers out there. If there is a better way to achieve this feel free to leave a comment.

Earlier this month, the Executive Office of the President of the United States of America relaunched their website, Whitehouse.gov, using Drupal. This week three members of the White House new media team presented at the Washington, DC Drupal users group. New media director Macon Phillips, deputy director of technology David Cole, and creative director Nik Lo Bue talked about their use of Drupal.

Watch the screencast here: http://vimeo.com/7669508

From the award announcement,

We are pleased to announce that Drupal has won the Best Open Source PHP CMS Category in the 2009 Open Source CMS Award. This category featured a very close contest between the top three, Drupal, WordPress, and Joomla! in which Drupal ended up as the overall choice for the judges and the public.

This is the highest award that Drupal was eligible for in 2009. Drupal previously won for Best Overall CMS in 2007 and 2008 has been placed in the Hall of Fame. The winners of the Hall of Fame Drupal awards for best Drupal theme and best Drupal contributed module will be awarded Thursday, November 12th, 2009. The themes and modules nominated were selected both for the most used and for a diverse set of nominees.

We use Drupal exclusively for building customized, scalable high end web applications. It’s no surprise developers, designers and users keep voting Drupal as Best CMS for years in a row. There is nothing you cannot do with Drupal. Being a CMF (content management framework), it is not pigeonholed into any one particular niche like Wordpress (strictly blogging applications).

What has Inclind done with Drupal?

• Integration with Microsoft Dynamics SOP System into Ubercart for product importing and inventory management
• Integration with Ubercart and Drupal into UPS Worldship for rock solid quoting
• Integration with UPS Worldship for automatic label printing for commerce orders
• Integration with Amazon S3 services for synced failsafe CDN (Content Distribution Network) support
• Integration with Windows LDAP Protocol support
• Integration with Invision Power Board Forum for external authentication of users through Drupal
• Integrated Ubercart as a management application of customers with interval based shipping orders (drop shipment / bulk ordering)
• Built routing algorithms to track and route best delivery methods for truck drivers on to Google Maps
• Built over 100 custom modules to meet the needs of individual clients
• … with more to come

Who else uses Drupal? Check it out!

• AOL
• The White House
• Yahoo
• IBM
• Bob Dylan
• The Onion
• CNN
• Metallica
• United Nations
• jQuery
• Sony BMG
• Michael Jackson
• Ozzy Osbourne
• EA Games
• Star Trek Online
• Mastodon
• Warner Bros
• CKY
• MTV
• MTV2
• SpreadFirefox
• SpreadThunderbird
• Computer World

Regional web development company Inclind Inc announces the launch of a brand new website this week for DJ Hook of Hook Productions of Bethany Beach, Delaware.Randy Vanderhook (DJ Hook) grew up with an ear for music. He joined the school band in elementary school on drums and continued with them on up through high school marching band for Indian River High School. When he had a chance to guest DJ he jumped at the opportunity and has enjoyed every minute of it since then, and Hook Productions was born.

With a huge library of thousands and thousands of songs (over 60,000!), DJ Hook prides himself on being one of the best DJ’s on Delmarva. Most DJ’s quit learning after figuring out how to hook up their system to a PA (public address speaker system) and still carry around bags and bags of CDs and large heavy rack based rigs. DJ Hook is constantly researching new techniques and using the most cutting edge hardware available, such as a computer based setup with a digital catalogue (making his setup far more compact and smaller than competitors).

DJ Hook has played numerous places in the Newark, DE area including Klondike Kate’s, Kid Shellie’s and East End. He has also performed at many popular hang outs in the beach area including Harpoon Hanna’s, the Chalkboard, Mackey’s, Fagers Island, High Stakes, Mickey’s Family Crab House, Brew River, Magnolia’s, Lifeguard competitions and many other private events such as weddings, anniversaries, birthday parties, corporate events and much more.Their new website (www.hookproductions.net) running on Inclind’s content management system allows Hook Productions to easily update the public on availability with their event calendar and lay out the booking process in detail. The calendar also shows public appearances DJ Hook makes, so you can attend events he will be DJ’ing at like Harpoon Hanna’s famous deck parties in the summer.

To learn more about how DJ Hook can cater your next event, please visit their website at www.hookproductions.net or call (302)-757-HOOK (4665). For more information on custom website development, please contact Inclind Inc. at (302) 856-2802 or online at www.inclind.com.

Inclind Inc has launched Dolly Parton’s Imagination Library website. Utilizing our powerful content management system (CMS) publishing platform, managing their website is quick and painless and allows them to get their important message out. Their objective is to supply a book a month to children aged 12 months to 5 years to promote literacy at a crucial time in the development of young minds. Opportunity and education are cornerstones of our country and its great that foundations like this exist to help future generations get a head start.

How Dolly Parton’s Imagination Library Started

Dolly Parton started this program in 1996 in her home county of Sevier, Tennessee, as a way to give back to her community and to promote literacy. She personally paid for each newborn child to receive a new board book, “The Little Engine that Could” by Watty Piper. Those children were also sent one new hard back book each month until they were five years old. On their fifth birthday, they received their last book, “Look Out, Kindergarten, Here I Come” a diploma, and a personal letter from Dolly for completing the program.

Here’s How it Works

A community must make the program accessible to all preschool children in their area. The community pays for the books and mailing, promotes the program, registers the children, and enters the information into the database. From there The Dollywood Foundation takes over and manages the system to deliver the books to the home.

Since 2001, the Dollywood Foundation has helped individual communities provide millions of books to children across America. The Imagination Library now provides books to children in over 700 communities, nearly all 50 states and two other countries including Canada and the UK.

About the Books

Penguin Group USA is the exclusive supplier of all of the books for the program. The free books are carefully selected to help develop a child’s literacy and vocabulary skills through age appropriate, developmental reading materials. There is a national committee of individuals who meet each year to review the Library. The committee is composed of representatives from Parents as Teachers National Center, the International Reading Association, the University of Tennessee, Rutgers University, and the teaching profession. New titles are introduced each year so younger siblings will not receive the exact same books as their older siblings.

Visit Dolly Parton’s Imagination Library Website »

So why Gmail? For starters, its really simple to import existing contacts into your system from your other accounts. Gmail also supports POP3 and IMAP- for free. This means that you can use any email client like Mozilla Thunderbird (also free) from any desktop and connect to your email. Last time I checked, Hotmail and Yahoo! both charged an annual fee to do this which is ridiculous. It isolates customers who don’t want to be tied to a web interface all the time. My storage cap at that time was like 250 MB, a ridiculously small amount. So it was no contest to switch to Gmail, who offer 6 GB to 8 GB per account, almost enough to last a lifetime (I have 7000 email conversations in my inbox).

Included with Gmail is Google Docs, Google’s online alternative to Microsoft Office. It is a lightweight application for basic word processing or spreadsheet creation. You can also share access with other Gmail clients (coworkers, friends, employees) by putting in their email address into the access list. They can then access the files and make revisions without ever having to connect to a server or downloading / uploading files, its all done from the web interface. And if that isn’t enough, Google Talk is embedded into the mailbox sections loaded with your contact list. If they also use Gmail, you can IM directly through Gmail instantly through the power of AJAX.

For those that are tech savvy like me and own an iPhone or iPod Touch, Gmail is supported fully either through Safari or the device’s Mail application- which to me is even more addictive than the Blackberry (Crackberry).

All of these reasons alone are enough to cut ties with other email services and sign up with Google. If that wasn’t enough, check out this article detailing 10 Reasons To Switch To Gmail.