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.

What are billboards (banners, header images, et al) you ask? Billboards are the large images you see on various websites that cover the header area. They typically contain marketing statements and imagery relevant to the websites purpose or page content.

Here are is one of my favorite examples:

Visit Southern Delaware Tourism Website

See that set of images just above the content, fading in and out? That is a billboard. With this module, you can create those in a matter of seconds.

After some brainstorming between Shaun and myself, we set out to create something simple, as simple as creating a Page node, without all the aforementioned hassle. After a week of coding, testing, testing and testing, we achieved just that. Now all you have to do is say, I want to create a Billboard, drop in your images (with a cool AJAX in-place uploader, you don’t even have to leave the page), and tell it what pages to display on and you’re done! It couldn’t be any simpler. You also have additional options available to you such as changing how the images display (random image, or fade in/out between images), setting ALT and Title tags for SEO (Search Engine Optimization), and select a resize option to size the billboard to (which is controlled and hooked into ImageCache!). Oh, on top of all of that, it’s all output via a single block. That’s right, you can have 100 billboards and just one block. Once you place it in the region, depending on your site theme, it’s ready to go. In the future you will be able to add blocks so you can have a billboard in the header, and also the footer or sidebar if you wish.

We have been taking feedback from our clients over the months, taking notes during training meetings, and analyzing massive amounts of performance data from our servers. It’s been pretty quiet in the blog, Facebook and our Twitter and it’s because we’ve been very hard at work. Over the last few weeks Inclind has been working at refining what we do in order to better serve, better train, and better our clients online presence. The Billboard module is just the tip of the iceberg, a precursor to the ultra-streamlined CMS package we have been putting together. There is so much going on, I couldn’t even begin to write up what will be coming in the next few months.

We’re here to serve you, to help you get things done faster, and make it so you don’t need a PHd to manage your site.

If you have any questions regarding Billboards, Drupal, our refined CMS package or need help managing your content, we are here to help. Give us a call at 302-856-2802, send us a tweet @inclindinc, or stop by our office.

zennette is #moonfruit even a FRUIT?

abllo wots with all this #moonfruit buzz?

Some are even formulating conspiracy theories:

SatansPuppet #moonfruit sounds like a filthy hippy movement it’s just as bad as communism!!

I am sitting back admiring Moonfruit’s marketing prowess and appreciating their product offerings. The DIY website template systems have come a long way in the 10 years I’ve been building websites. At this point, I believe there are only a couple of systems capable of providing you with the tools you need to not only build a basic site but also extend it. Drupal and WordPress are the cream of the crop of base content management systems. Being built on PHP they are lightning fast, and also being open source allow you to customize and add on to the code providing your own solution. For example, integrating ecommerce with inventory management capabilities of Microsoft Dynamics, like we did with Dogfish Head Craft Brewery’s new ecommerce store (https://www.dogfish.com/store/index.htm).

But hats off to Moonfruit for a smart marketing campaign.

This will be the first time the band has released a studio album with more than 11 tracks. It is expected that the total length of the album will also exceed 35 minutes, another first for the band, with potentially two instrumentals.

What happens when four exceedingly different and distinct personalities come together to create heated, inspired music? Well, as CKY have shown over their ten plus years as a rock and roll force, it can lead to intelligent, provoking riffs and lyrics, meticulously detailed production combined with magical multi-textured melodies and heady drumming. But, “it also creates tension, tension that must be let off,” says the band’s singer/guitarist, Deron Miller.

Not too long ago, ten years of tension caught up with the West Chester, Pennsylvania outfit. Producer/guitarist Chad I Ginsburg says the band “ended up physically beating each other up at once on their tour bus,” CKY decided to take an extended timeout. “We needed a break, more than just the kind of break you think,” explained Miller. A break leaving drummer Jess Margera and bassist Matt Deis wondering what future, if any, there would be for CKY.”

The band were halfway through the writing of their forthcoming album, Carver City (which was recorded and produced by Ginsburg at his new Studio CIG in Pennsylvania), CKY found itself unable to resolve internal issues, resulting in the band being put on the backburner. For an entire year, Ginsburg and Miller did not speak, nor did Miller and Margera. This extremely uncomfortable time away from the thing they loved most would allow the band to overcome the many lingering obstacles standing in the way of their greatest effort to date, Carver City, which hits stores May 19.

“We could have just said, ‘F**k it. We’re not going to finish the record.’ But no one could make that decision.” says Ginsburg. “When we finally got together to resume the sessions, we didn’t talk about the past or what had happened. We didn’t look back. The passion came back blazing, in a distinctly different, effective and inspiring way. Yeah, We took a year off by accident. But, I really think it helped the music greatly.”

Carver City is CKY’s first album of new material since 2005’s An Answer Can Be Found, and the band’s first studio offering since its split from Island Records in 2006. “Having a studio at my house, gave me the ability to work on [Carver City] for literally several thousand hours, for two years straight,” Ginsburg says. “We added a ton of new textures. Layering has always been something we’ve been into; guitar textures alone tend to bore us, [Carver City] is sonically, our best effort to date.”

Thematically, Carver City is part fantasy, part autobiography. To assist in the completion of the album, CKY concocted the fictional town of Carver City to help them. Miller and Ginsburg inhabited this imagined municipality with notoriously bad luck with dozens of illusory characters, and even created an elaborate history behind Carver. At its heart, Carver City is a late 1970’s/early 80’s-era seaside resort town, much like Wildwood, New Jersey – a place Miller visited often with his family when he was a child. The song “The Boardwalk Body” was directly inspired by one such visit, when Miller says police discovered a corpse underneath the boardwalk. “Lyrically and musically, it all reminded us of that nostalgic beach vacation feeling,” Miller says.

Carver City (which features album art by Travis Smith) is perhaps CKY’s most challenging and creatively gratifying endeavor to date. Conceiving Carver City and its folklore helped the band complete what was becoming an exhaustive writing/recording process, at a time when they were still recovering from their near-meltdown. The band is back on solid ground again, back with a vengeance and a record that the band’s allegiant fans will appreciate. As Ginsburg puts it “the world didn’t end, CKY still exist and are better than ever.” “Trying to please each other and ourselves…that’s always the challenge,” says Ginsburg. “We wouldn’t release a note at this point if we didn’t dig what we were doing. This whole record was done basically without speaking to each other. It was just the music, and work, work, work all the time, with no bullshit. Learning to solely communicate through the music alone was tough but I know we did the right thing taking our time with Carver City.” This summer, to coincide with the resurgence of CKY and the release of Carver City, Ginsburg, Miller, Margera and Deis will be hitting the road bringing the unique energy and atmosphere that only a CKY show can.

John, one of their sales guys out west, remarked how innovative, easy and exciting their new site is in terms of marketing, and “he’s been doing this for a very long time”.

We do all of our training sessions and troubleshooting via Cisco WebEx, which allows us to teleconference via phone multiple people at once and share computer screens. That way we can walk people through managing their site in real time, from wherever. Additionally, via screen share, we can switch at any time and let them show us any problem areas they may be seeing, which is essential in a mixed browser, mixed PC/MAC hardware environment where static development environment variables cannot be guaranteed.

You’d be surprised at the differences in javascript handling alone between Safari (common on Mac) and Internet Explorer are (common on PCs), let alone rendering HTML and CSS. Which is why it’s also important that we stick as close to web standards as possible, so everyone has the same exact experience when using a website. Well, everyone but Internet Explorer 6 users. We do all we can to help you, but please upgrade your browsers!

Of course, you don’t have to be Dogfish Head to enjoy the same level of service. We offer the same service to all our clients and/or future clients who are in need of a web design / web developement company of a higher calibre.

I had a lot of time to think during the convention, comparing and contrasting us from other developers. It wasn’t until I took my car into Jiffy Lube this weekend that I put it all together.

You see, like Jiffy Lube, we provide a service. You bring your car to them, they dissect and analyze the cars performance, problem areas, etc, and discuss the solutions with you. They complete all of this in under a half hour. You can take your beater, BMW, or tricycle. They are qualified to service any vehicle. In a way, its not that different from developing websites.

When a client comes in the door, they have an idea. Whether its big or small, its an idea. We’re here to help that idea become a reality, to provide a value added service for you. Of which, we employ many of our programming toolsets and human talent in order to execute the idea to its fullest extent. It doesn’t matter what idea you bring to us, we’re going to pursue every possibility in building a solid, stable working relationship with the client so that both parties get what they want and more importantly, have fun while doing it. Everyone working in unison, a well oiled machine, just like a Jiffy Lube team.

When this baby hits 88 miles per hour, you’re going to see some serious shit.

Small town, small company. Big talent, big ideas. You don’t have to be some fifty plus sized company in a NYC loft to be big time.

If you think small, you’ll be small.

Folks know value when they see it too, which is why they come to us. There are a lot of patchwork web companies around the world. What is a patchwork web company? Well, in simplest terms, a patchwork web company is one that slaps together images and premade code for a cheaper price just to complete a contract. This leaves the customer unsatisfied long term, and their website is a house of cards waiting to implode. For example, most people are content getting by by selling someone a WordPress site with a design template for $2000 or less. Short term, it pays the bills for the shop, and feels good for the client to pay so little. But as time moves on, they will see they got what they paid for. Locked into the framework unable to scale or adapt new ideas, unreliable hosting uptime, and no true ‘ownership’ of their website.

If you can’t change aspects of the site, then you don’t really own it!

In these terms, it always reminds me of my favorite Tom Green skit, Undercutters Pizza.

There’s always someone out there somewhere, ambulance chasing, bidding low to win your favor and screwing you in the end.

That’s heavy, Doc.

Right. So what does it all mean? Caveat emptor, you get what you pay for. We may be a little bit higher than other companies, but we’re going to stand behind you and your site because that’s what you deserve. Inclind has a vested interest in your future, not hitting the road once you’ve paid us. Your future is our future. It’s a symbiotic relationship.

We’re poised for big things this year. You’re welcome to join us.

Hit it, Marty.

Their new site has everything they have been wanting and more. Dogfish Head Brewery can now easily manage their 800 page (and growing!) website, all its users, media, newsletters, news articles, events, RSS feeds, and comments. They can add/remove ‘locations’ of where their product is sold, served, or distributed. This allows customers to log in and see where they can find Dogfish on the ‘Fish Finder‘. Try it out!

With that, the new site features a fully functioning community section and social network. Users can register on the website for an account, after which they can create a basic profile. From there, they have access to submit a map location to their Fish Finder, add or comment on threads in the Forum, submit questions to Dogfish staff in Ask Dogfish, comment on Dogfish staff blogs (Blogfish), and connect with other Dogfish loving fans. All applicable content is able to be sent instantly through Twitter/Digg/MySpace/Facebook/etc in a single click of the ‘Share’ button. We really went all out to flesh out the community side and give users stuff to do in between staff blogs and answering questions.

Our new system that was used on Dogfish Head Brewery has no official name yet, or I’d tell you what it is ha. We hope to have that nailed down soon. What I can tell you is that its the most feature complete, stable and scalable CMS you are going to find on the east coast. I would put it up against anything the competition has to offer from Maine to Florida with confidence ours is as on par or better than what else is available. Since the code is modular, its not coded for 1 strict specific project (as we used to) but rather, any client who comes in the door can have the same power, accessibility, UI and functionality of big time folk like Dogfish. In other words, it makes our platform highly scalable and consistent.

All ya gotta do is ask us.

As for the rest of the week, Pete, Trey and Kevin are representing Inclind at DrupalCon in Washington DC. They will be talking to fellow developers and programmers and sharing / showing off work. You can follow what we’re up to on our Twitter (either by going to the Twitter site, or the side of our page on this site, or adding us inclindinc).