Seven Ways to Make Money From Your CRM

Can a CRM (Customer Relationship Management) system really create profits for a company? A lot of people don’t think so – over the years the media has reported quite a few companies (both big and small) that have tossed a significant amount of dollars down the drain on these kind of systems. But there have been plenty of successes too. In fact, during the 12 years we’ve been selling and implementing CRM products like GoldMine and Microsoft CRM we’ve seen some penny pinching business owners really get a lot of bang for their bucks. Here’s how.

The Lonely Old Quote: Tyler, who runs a parts distribution company had a big problem: one of out of every ten quotes his salesmen sent were never followed up! Sure, some of these opportunities may have been lost to others, but Tyler wondered just how many of these quotes could’ve turned into a sale if someone would’ve just called the customer. The problem? He had no system to track his quotes! Tyler made changes – he purchased a simple CRM system and made sure that each quote was tagged with a follow-up call and alerts to the sales staff when they were due. He also built in an alarm for his sales manager in case a salesperson was ignoring his follow up calls. Within a few weeks Tyler could see the difference. Every quote was now pursued with either a phone call or email.

Opportunities that could’ve slipped through the cracks were now addressed. Sales increased.

The Bright Side Of A Lost Sale: Don, a penny pinching manager at a consulting firm, actually thinks there’s a bright side to a lost sale. “Because of our CRM system,” he says. “We can track every time a sale does not go our way.” Sometimes a competing product beat them. Other times a customer decides not to do anything at all. Whatever the reason, Don’s company tracks the history and every three months runs a Lost Sales Report and does a post mortem. It’s never pretty. It’s oftentimes frustrating. “But it’s ALWAYS educational,” Don continues. “Armed with where we screwing up, we can adjust and win back more dollars going forward.” And he wouldn’t be able to do it without his CRM system.

Too Few Sales Calls, Too Many Donuts: Jim, another penny pinching manager who works at a large cable company was often confronted by sales guys asking for more money. Jim always turns to his CRM system and says, “Well, let’s take a look at the old batting average”. Here, Jim can see how many quotes a salesperson put out vs. what he closed. “Now, now,” Jim chuckles. “What can we do to increase this percentage so YOU get more money.” Jim tracks his sales people’s calls and appointments and looks at their productivity. “Now why did you spend so much time with this little prospect, when you could’ve been spending more time with that bigger fish?” A good CRM system helps the penny pincher squeeze the most efficiency from his sales team.

Don’t You Hate Looking Like A Dope? The other day Harry, a sales rep for a software company, called one of his customers to tell them all about the great features coming in the software’s up and coming new release. He wasn’t prepared for the response he got. “New release?” his customer yelled. “How about getting the OLD release working first!” Because Harry’s company didn’t have a CRM system he had no idea that his service group was working on a problem with this customer. His call did nothing more than enflame emotions, rather than creating good will. More dopey moments like that and Harry could watch his sales disappear. A good CRM system ensures that everyone in the company knows everything that’s going on with your customers. And your prospects, vendors and other parties too. This way no one looks like a dope when representing your business.

Too Few Service Calls, Too Many Donuts: It’s not just penny pinchers who recognize the value of time as well as money. But good penny pinchers do something about it. Do you have a system that tracks how employees spend their time on issues, problems, breaks and other customer complaints? Is service time being wasted? Are there service issues that aren’t being addressed? How come this one part has so many problems? Should we keep doing business with that customer who calls us so much? Can you get an alert when certain issues are breached? Using CRM software to track how productive your service group is will save a lot of pennies in the long run.

Fun And Games With Duplicate Data: For goodness sake, just how many places do I need to keep the same information? Sandy kept asking herself this question. A typical penny pincher, she hated the fact that customer information was entered in her website, in her accounting system, in her email system, in spreadsheets and other databases. “Enough!” she yelled. She got a CRM system. She designed one web form to capture the customer data and the CRM system took care of that. The same data was sent automatically to other systems. Accounting and inventory information stayed in her financial system, but her CRM system was able to be configured to view that data. Enter it once, make it available elsewhere. Buying a good CRM system? A few thousand bucks. Using it to eliminate wasted time and incorrect data entry? Priceless!

Getting the word out – mass communications: Alexis knew that the more customers she could reach, the more opportunities she could create and even more pennies would drop into her bank account. So she configured her www.marksgroup.net CRM system to send out automatic emails to customers who hadn’t ordered in a while and to customers who ordered a product in the past who may be interested in an accessory or similar product. She produced with her system direct mail pieces each day announcing specials. She created a newsletter to keep her customers informed about new developments. Her CRM software sent out faxes to groups of customers who gave her permission to alert them to new incentives. She scheduled groups of telemarketing calls to be made by high school kids in the evening. Alexis is no mass marketer but she’s certainly a great penny pincher. And her bottom line shows the results! 

Source: http://www.smartbiz.com

By:  Gene Marks

Tutorial on NAnt: How to install and configure

NAnt is a free .NET build tool based on Ant (a build tool for Java). NAnt, like Ant, is similar to Make in that it is used to generate output from your source files. But where Ant is Java-centric, NAnt is .NET-centric. NAnt has built-in support for compiling C#, VB.NET, and J# files and can use Visual Studio .NET solution files to do builds. NANt also has built-in support for NUnit and NDoc (.NET version of JUnit and JDoc, respectively).

NAnt is a useful tool for automating the build process. The build process can include tasks such as compiling source code and resource files into assemblies, running unit tests, configuring build-specific settings, and so on. The benefit of tools like NAnt is that they help automate the build process by providing enough power and flexibility to highly customize build actions for specific applications. This article provides an overview of NAnt, including its purpose, how to download and install NAnt, using NAnt, and other NAnt essentials. Read on to learn more!

What is a this thing you call Build Tool?

A “build tool” is a tool that you use to build your source code and resources files into assemblies.  We use build tools everyday in development.  Here are some tasks that are performed during the “entire” build process:

  • Get latest source code from source code control (SVN/VSS/CVS).
  • Configure the build (put files in specific folders based on build number).
  • Compile the code
  • Run Unit Tests
  • Create Documentation from the source code comments
  • Include non-code output files in the output of the build (images, database files, config files, etc..)
  • Package the output for deployment

NAnt and other build tools allow you to automate some or all of these steps.  You can configure the build tool to kick off the processes and automate a lot of work that is usual manual and tedious.

OK So what does NAnt do?  Why is it the best?

NAnt is different.  Instead of a model where it is extended with shell-based commands, NAnt is extended using task classes.  Instead of writing shell commands, the configuration files are XML-based, calling out a target tree where various tasks get executed.  Each task is run by an object that implements a particular Task interface.

Granted, this removes some of the expressive power that is inherent in being able to construct a shell command such as ‘find . -name foo -exec rm {}’, but it gives you the ability to be cross-platform – to work anywhere and everywhere. And hey, if you really need to execute a shell command, NAnt has an <exec> task that allows different commands to be executed based on the OS it is executing on.

What is Required?

The system requirements are pretty obvious and simple.  To use Nant you need one of the following CLR’s:

  • Microsoft .NET Framework 1.0
  • Microsoft .NET Framework 1.1
  • Microsoft .NET Framework 2.0
  • Mono 1.x

Note: Additional requirements may apply to individual tasks.

NAnt uses a number of open source third party libraries.  Recent versions are included with NAnt distribution and no extra work is required to install them.  More information on these libraries are available at:

> NUnit – Required for unit testing

> NDoc – Required for documentation generation

> SharpZipLib – Required for the zip and unzip tasks

OK So it sounds like I need it, How do I install it?

NAnt is available in either a source or binary distribution. The binary distribution is all you need to use NAnt to build your projects, including creating your own custom tasks, types and functions.

If you are upgrading NAnt from a previous version, you must never install over the top of your previous installation. Delete or rename the existing installation directory before installing the new version of NAnt.

Installing from binaries

  1. Download the binary distribution archive. Either ant-bin.zip or nant-bin.tar.gz will work, the contents of each archive are the same.
  2. Remove any previous versions of NAnt you may have installed.
  3. Extract the contents of the archive to the location you wish to install NAnt (eg: C:\Program Files\NAnt in windows, or /usr/local/nant in Linux)
  4. Depending on your environment, create a wrapper script to run NAnt:
    Run NAnt using Microsoft.NET
    • Create a file called nant.bat in a directory that is included in the PATH system environment variable. (eg. C:\WINDOWS).
    • Add the following to nant.bat:
      @echo off
      "C:\Program Files\NAnt\bin\NAnt.exe" %*
                              
    Run NAnt using Mono
    • Windows
      • Create a file called nant.bat in a directory that is included in the PATH system environment variable. (eg. C:\WINDOWS).
      • Add the following to nant.bat:
        @echo off
        mono "C:\Program Files\NAnt\bin\NAnt.exe" %*
                                        
    • Linux / Cygwin
      • Create a file called nant in a suitable location in your filesystem (eg. /usr/local/bin).
      • Add the following to nant:
        #!/bin/sh
        exec mono /usr/local/nant/bin/NAnt.exe "$@"
                                
      • Ensure nant has permission to execute, eg:
        chmod a+x /usr/local/bin/nant
                                
  5. Open a new command prompt (shell) and type nant -help. If successful, you should see a usage message displaying available command line options.
  6. (optional) Download and install NAnt-contrib or other third party extensions to NAnt.

Installing from source

  1. Download the source distribution archive. Either nant-src.zip or nant-src.tar.gz will work, the contents of each archive are the same.
  2. Remove any previous versions of NAnt you may have installed.
  3. Extract the contents of the archive to a temporary location. This should not be the location you wish to install NAnt to.
  4. Open a command prompt and change into the folder you extracted the archive to.
  5. Depending on your environment, build the NAnt distribution:
    Install NAnt using Microsoft .NET
    • GNU Make

      make install MONO= MCS=csc prefix=<i>installation-path</i>

      eg. make install MONO= MCS=csc prefix="C:\Program Files"

    • NMake

      nmake -f Makefile.nmake install prefix=<i>installation-path</i>

      eg. nmake -f Makefile.nmake install prefix="C:\Program Files"

    Install NAnt using Mono
    • GNU Make

      make install prefix=<i>installation-path</i>

      eg. make install prefix="C:\Program Files"

    • NMake

      nmake -f Makefile.nmake install MONO=mono CSC=mcs prefix=<i>installation-path</i>

      eg. nmake -f Makefile.nmake install MONO=mono CSC=mcs prefix=/usr/local/

    This will first build a bootstrap version of NAnt, and then use that to build and install the full version to <i>installation-path</i>/NAnt.

  6. Follow the instructions as for a binary release from step 5.

 

Installed….CHECK!  Now how does it work?

NAnt is a command-line application that acts on build files that you write in XML. Each build file contains one project and any number of properties and targets. A property is a variable and a target is a set of tasks. An example is worth a thousand words, so here is Hello World as an NAnt build file:

<?xml version="1.0"?>
<project name="Hello World" default="hello">
    <property name="hello.string" value="Hello World" />
    <target name="hello" description="Echoes 'Hello World'">
        <echo message="${hello.string}" />
    </target>
</project>

NAnt looks for build files in the current directory with a .build extension. If there is more than one build file in the current directory, NAnt looks for one named default.build and, if present, uses it. You can explicitly specify the build file to use with the -buildfile:<i>&lt;filename&gt;</i> command line argument.

All NAnt build files require one (and only one) &lt;project&gt; tag. In the ‘Hello World’ example, the &lt;project&gt; tag contains the default argument. The default argument specifies which target NAnt is to execute by default. In this case, NAnt will execute the hello target by default.

The ‘Hello World’ example defines one property and one target. The property is named hello.string and its value is ‘Hello World’. (Properties don’t have to be named with periods, but often are in NAnt build files). The ‘Hello World’ example’s one target is named hello and it contains one task. The &lt;echo&gt; task echoes the string indicated by the message argument. The syntax ${hello.string} may be confusing at first, but this syntax is simply telling NAnt to substitute the value of the hello.string property in its place.

Assuming you named the ‘Hello World’ example build file default.build, you would simply enter nant at the command line to build it:

C:\>nant

(You could specify the ‘hello’ target on the command line (C:\&gt; nant hello), but since this is the default target, this is unnecessary.)

How about a More Practical Example?

Here’s a build file (based on the excellent article by Giuseppe Greco, Building Projects With NAnt) that compiles a HelloWorld.cs source file. In addition to the build target, it includes a debug target. This enables you to specify whether or not this build should including debugging information:

&lt;?xml version="1.0"?&gt;<br>&lt;project name="HelloWorld" default="build"&gt;<br>&nbsp;&nbsp;&lt;property name="project.version" value="1.0" /&gt;<br>&nbsp;&nbsp;&lt;property name="project.config" value="release" /&gt;<br>&nbsp;&nbsp;&lt;target name="init"&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;call target="${project.config}" /&gt;<br>&nbsp;&nbsp;&lt;/target&gt;<br>&nbsp;&nbsp;&lt;target name="debug"&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;property name="project.config" value="debug" /&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;property name="build.debug" value="true" /&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;property name="basedir.suffix" value="-debug" /&gt;<br>&nbsp;&nbsp;&lt;/target&gt;<br>&nbsp;&nbsp;&lt;target name="release"&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;property name="project.config" value="release" /&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;property name="build.debug" value="false" /&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;property name="basedir.suffix" value="-release" /&gt;<br>&nbsp;&nbsp;&lt;/target&gt;<br>&nbsp;&nbsp;&lt;target name="build" depends="init" description="compiles the source code"&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;property name="build.dir" value="${nant.project.basedir}/${nant.project.name}_${project.version}${basedir.suffix}"/&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;mkdir dir="${build.dir}" /&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;csc target="exe" output="${build.dir}/HelloWorld.exe" debug="${build.debug}"&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&lt;sources&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&lt;includes name="HelloWorld.cs" /&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&lt;/sources&gt;<br>&nbsp;&nbsp;&nbsp;&nbsp;&lt;/csc&gt;<br>&nbsp;&nbsp;&lt;/target&gt;<br>&lt;/project&gt;

Things to notice about this build file:

  • There are targets for debug and release. You include these targets on the command line to specify the type of build configuration. Notice that release is the default configuration.
  • The build target has a depends argument. This tells NAnt to make sure the init target is up to date before calling the build target.
  • The init target calls another target explicitly. In this case, it calls either the release or debug target.
  • The output is put into a directory that is named with the project version and configuration (1.0_HelloWorld-release or 1.0_HelloWorld-debug)

Assuming you have a valid HelloWord.cs file in the same directory as the build file, you can build the release version of this project just by entering nant at the command-line. This is equivalent to entering nant release build, but because project.config is set to release by default and the default target is build, this isn’t necessary.

If you want to do a debug version of this project, use the following command: nant debug build. Note that you must specify the build target in this case. If you specify any targets on the command line, NAnt ignores the default target. If you just entered nant debug, NAnt would have executed the debug target and then exited. If you notice that the debug target is called twice when doing a debug build, you can move to the head of the class. It is called first because you specify it on the command line and a second time by the init target. This is not as efficient as it could be, but I left it this way for simplicity.

Obviously we are just scratching the surface of what NAnt can do with the above example.

What is the Workflow of a Build Using NAnt?

Once you have your build file(s) written and tested, you will want to start using them for your builds. Performing a build with a build tool like NAnt usually involves these steps:

  1. Set a version property in your build file to the value for the current build (you could also pass this to NAnt on the command line)
  2. Get the latest source from source code control (if you do not have NAnt do this for you)
  3. Run NAnt with appropriate command line targets (debug build, for example)
  4. Wait for the build to complete (you can use NAnt’s &lt;mail&gt; task to have NAnt notify you by email when the build completes; this is useful for solutions that require especially long builds)
  5. Handle any build errors. NAnt will fail if it encounters any errors. If a file fails to compile, for example, NAnt will fail. You can configure some tasks to either fail or not fail on error. The &lt;copy&gt; task is an example.
  6. If the build succeeded, deploy the build output. (NAntContrib includes an &lt;msi&gt; task if you want to create .msi installation packages from NAnt.)

You can actually automate the NAnt build process using continuous integration tools like Draco.NET and CruiseControl. These tools monitor your source code and automatically perform builds when they detect changes.

Well I took my first Transcender test today…

First, I will give an overview of what the test was like and then I’ll give you my review of it.

The test was given to me to try and gauge my skills as a .NET Web Developer.  The test was 35 questions and it took around 30 minutes to complete.  It was the c# web 315 test.

I would say the questions broke out something like this:

25% DataSet questions

20% Questions dealing with signing of .dlls

15% SqlClient connection syntax

15% Web.config environment syntax questions

10% Configuring IIS

10% VB6/COM Interoperability with .NET

5 % MISC

Some of the questions where multiple choice, while others were multiple answer checkboxes.  The test did a good job of mixing up the questions so that they were dispersed evenly over the 30 minutes.

My Summary/Review 

Well after this exam, I remembered why I’ve never tried for MCSD.  As you can see from the percentages above there were no questions about 1.) Object oriented design.  2.) n-tier design. 3.) design patterns of any type.  25% devoted to DataSets?  I refuse to use DataSets 90% of the time when developing web applications.  Yes! There are times when DataSets are useful.  YES! Datasets have come a long way in ASP.NET 2.0, but I am not going to memorize the syntax to all of the Merge, Data Relationship, Table methods/properties. 

In my opinion, the only way to find out what a person knows about a technology is to sit down with them and walk through code manually and talk about it.  Ask questions like “Do you know why we did this?”.  “What would you do here to make this more efficient”.  Write up an architecture diagram for a mock customer/project.  These are the things that you are going to be faced with as a developer in front of a customer.

I just don’t get how these Transcender tests or a MCSD license is any indication of your skills as a software developer / architect.

Thank you Microsoft for recent .NET Support!

Well I just wanted to give a formal thank-you to Microsoft for it’s recent support of extending the tools for Microsoft Web Developers.  I’ve been pretty tough on Microsoft over the last year on it’s issues with Microsoft Visual Studio 2005 and it’s massive delay on releasing SP1. 

As most of you know, ASP.NET AJAX v1.0 was officially released last week.  The release was accompanied by loads of videos and sample code that should get any .NET Developer off the ground and running with AJAX in no time at all. 

Most of the thanks goes to the wonderful developers responsible for developing ASP.NET AJax, but certainly Microsoft has done a lot to make these tools happen.

Here are some links to get you started:

- Main ASP.NET AJAX site: http://ajax.asp.net

- ASP.NET AJAX Download.  With ASP.NET AJAX, developers can quickly create pages with rich, responsive UI and more efficient client-server communication by simply adding a few server controls to their pages. This new Web development technology from Microsoft integrates cross-browser client script libraries with the ASP.NET 2.0 development framework. ASP.NET AJAX provides developers building client-based Web experiences with a familiar development process and programming model that they already know from using server-side ASP.NET development. Because ASP.NET AJAX is integrated with ASP.NET, developers have full access to the built-in ASP.NET 2.0 application services and the entire .NET Framework. 

- ASP.NET AJAX Control Toolkit.  The ASP.NET AJAX Control Toolkit offers developers a rich variety of client-side controls and extenders through a compilation of code samples and components. If you’re looking for eye-catching control behavior without having to go through the trouble of writing and testing extensive JavaScript code or adding complex animations, the ASP.NET AJAX Control Toolkit offers the right balance of visuals and ease-of-use.

- ASP.NET AJAX Library.  The Microsoft AJAX Library is a standalone collection of the standards-based JavaScript classes included in ASP.NET AJAX. It’s supported by most popular browsers and can be used to build client-centric Web applications that integrate with any backend data provider.

I suggest everyone take a look at these wonderful .NET tools.  AJAX is not going away anytime soon, and it is important to realize the benefits that this “old but re-juvinated” techology is bringing to the web.

Internet Explorer 7.0 is Officially Released

Microsoft announced the release of Internet Explorer 7.0 today.

Download Link

Release Notes Link

Internet Explorer 7.0 Checklists

Hurricane Katrina: Who paid for the Louisiana Superdome?

Let me first say that I’m a huge football fan and I think bringing football back to Louisiana is import for the state.  That being said, I also think that it could have waited another year.

Hurricane Katrina absolutely destroyed the Superdome.  The roof was ripped off, and the entire complex was in shambles.  People have debated since then on whether the team should move or the stadium should be rebuilt.

The state decided to rebuild the stadium at a cost of $180 million. 

Here are some facts about the process:

The majority of the population of the gulf coast region is still living in Houston or Baton Rouge or Atlanta or wherever, largely because FEMA hasn’t gotten around to replacing or repairing anything but a handful of the homes and buildings and other critical infrastructure destroyed by Katrina.

Here’s who footed the bill for the new and improved Superdome:

  • FEMA: $115 Million
  • State of Louisiana: $13 Million
  • NFL: $15 Million
  • LSED Bond: $41 Million

Total: $184 Million

So that works out to 62.5% being paid for by the federal government – less than the 75% required by law, but almost certainly more than just “previous quality.”

All this, in addition to the new and improved FieldTurf (which is a substantial upgrade over the old AstroTurf playing surface).

Nothing was done to improve the Superdome’s capability as a storm shelter. It is estimated that those upgrades would cost an additional $30-$40 million.

I sure hope my free tickets are in the mail since I’m now a partial owner of their stadium.

ConnectionTimeout vs. CommandTimeout

I was asked the question today why a sql query was timing out.  A co-worker explained that he changed the ConnectionTimeout setting and it was still timing out.  I thought i’d post about the differences between CommandTimeout and ConnectionTimeout.

ConnectionTimeout is the one specified in your connection string and it is the time it takes for a connection.Open() invocation to wait until it gets a connection reference from the connection pool.  (Default value is 15 seconds)

CommandTimeout is the maximum time for a specific sql command to execute.  (Default value is 30 seconds)

DotNetNuke has gone Corporate

First let me say that I have worked on DotNetNuke for the last five years.  It is the best open source product i’ve ever seen.  The project has wonderful developers and is always innovating.

Today they announced the formation of DotNetNuke Corporation.  This is exciting for me to see since I have been involved in DotNetNuke since the early beginning.  I’ve used the software in many projects and have built lots of custom modules.   Here is the press release:


Worldwide popularity of DotNetNuke enables new organization to pursue wide range of opportunities to benefit the community

Seattle, Wash. — September 21, 2006 — DotNetNuke®, the popular Open Source web application framework for the ASP.Net platform, today announced the formation of DotNetNuke Corporation, a new company to serve the growing needs of the project and its ever-expanding community. The new entity will focus on the management of the project, while leveraging a wide array of resources to create and distribute a superior, free, Open Source web application framework that cultivates a passionate developer community and a prosperous commercial ecosystem.

“The formation of this company reflects the maturity of the DotNetNuke project,” said Shaun Walker, founder of DotNetNuke Corp. “As the adoption rate of DotNetNuke continues to grow, it is increasingly being used as a platform for mission-critical websites and web applications. DotNetNuke Corp. exists to instill confidence that while the project continues to remain true to its Open Source ideals, it will also be backed by a company that is focused on providing professional management and stewardship for the project.”

Perpetual Motion Interactive Systems, Inc., Walker’s British Columbia, Canada-based company that currently manages the DotNetNuke® project and its intellectual property including trademarks, will transfer these assets to DotNetNuke Corp., which will be based in Seattle, Washington, Walker said. The new company will maintain the primary authority for managing the Open Source project, stewarding and distributing the source code, setting policies, managing intellectual property, and organizing the relationships between all participants in the project.

“DotNetNuke Corporation is not a typical commercial entity,” Walker added. “Rather, it is dedicated to the public benefit goal at the heart of the DotNetNuke project, which is to create opportunities and spread entrepreneurship to the world by providing a superior Open Source web application framework.”

The project continues to be successful in achieving this goal. In the four years since the DotNetNuke project was launched, it has seen its registered user ranks swell to 335,000 members and demand for its flagship product surpassing 2 million downloads worldwide. This worldwide adoption of DotNetNuke has created significant economic value both for the project and also the commercial ecosystem that it has spawned.

“This economic value is an unintended but real by-product of the DotNetNuke project’s overarching mission to create opportunities and spread entrepreneurship to the world,” Walker said. “Carefully managed, this value — and the resulting ability to generate revenue — can be used to make the DotNetNuke project self-sustaining and help keep the community open and diverse.”

In addition to spearheading the Open Source project, DotNetNuke Corp. will also focus on developing and delivering services which support the ecosystem, including marketing, sponsorships, and a wide range of partner-related activities. These activities are expected to generate revenue, but the company intends to focus on those opportunities that are consistent with the community values and public goals of the project, Walker said. This includes providing funding for aspects of the project that are difficult or challenging for volunteer teams to solely undertake such as professional marketing, large-scale platform and feature development, product certification and ecommerce initiatives, he added.

“Overall, the operation of the DotNetNuke project will remain unchanged,” Walker said. “Participants in the DotNetNuke project will not experience any difference in the way the DotNetNuke application is developed, licensed or distributed. As DotNetNuke Corp. adds resources in those areas that are currently lacking, we expect to see improvements that will have an overall positive impact on the project,” Walker said.

The current members of the DotNetNuke project management board – Joe Brinkman, Nik Kalyani and Scott Willhite – will join Walker as co-founders of the new company.

About DotNetNuke®

“Our mission is to create opportunities and spread entrepreneurship to the world by providing a superior open source web application framework which cultivates a passionate developer community as well as a prosperous commercial ecosystem.” DotNetNuke® is an open source web application framework ideal for creating, deploying and managing interactive web, intranet and extranet sites. With a rapidly growing community of over 300,000 registered users, a legion of dedicated professional developers, and an active commercial ecosystem, DotNetNuke® continues to strengthen its leadership position in the Microsoft enterprise market.

About Open Source

The basic idea behind Open Source is very simple: When programmers can read, redistribute, and modify the source code for a piece of software, the software evolves. People improve it, people adapt it, and people fix bugs. And this can happen at a speed that, if one is used to the slow pace of conventional software development, seems astonishing.

Where were you on September 11th, 2001?

9/11

September 11th, 2001 will be a day that will be remembered by everyone.

The country changed that day, and our lives will never be the same. The terrorist indeed did exactly what they wanted. They were able to invoke pandemonium on the United States. People rushed to gas stations in fear of gas shortages. The Government shut down all major transportation vehicles and closed all large buildings.

Here is my recollection of the day:

I arrived at work at 8:00 a.m. I was working at SFA Solutions at the time as a CRM Consultant. I had a 9:00 a.m. meeting at Menttium Corporation to discuss customization plans of their Oncontact CRM package. Brett Greenberg was to meet me their. Just as I was leaving, I got a tip from a co-worker that something had happend in NYC and an explosion had occurred.

I remember jumping on CNN and the network was slower than usual. So I jumped in my car and tuned into the local news station. It took me 40 minutes to get to the office building and when I meet Brett there, we just sat in our cars and listened to the news break. They explained that a Jet had collided with one of the towers and that the building was burning.

When finally peeled ourselves away from the radio and went into the client’s building for our engagement. As you can imagine, the employees at Menttium were not in a mood to discuss anything and we just sat by a radio that they had. I plugged in my laptop and followed the news on the major news websites. (CNN, Yahoo, etc.) I’ll never forget some of the pictures and video clips they showed that day. The video of the plane hitting and the huge fireball. The people jumping out of the windows to prevent burning to death. It was the worst even I have ever seen with my eyes. It seemed like the entire country stopped that day. Again, the terrorists had done everything they wanted.

Out of all those visual challenges, one thing sticks out the most. When I was at the client’s office I heard a woman crying out loud. I walked over to where the noise was coming from and two women were trying to comfort one of their co-workers. She was watching the footage on a small T.V. and she was crying and mumbling words that nobody could comprehend. We could not calm her down nor get her to stop crying. At that exact momemnt, I had flashbacks of watching peoples reaction to the Kennedy Assassination. I wonder if this is how people felt?

It is now 5 Years later and we are still seeing the effects of that day. Our transportation system has been re-vamped. We have gone through two wars and terrorism seems to be much closer to home than it was for me growing up. I do feel safer today than I did 5 years ago. I think a lot of great things have come out of the 9/11 attacks. I loved the way the country came together. I loved seeing people on bridges waving American flags as I drove under them.

I’m very thankful for all the men and women that were involved in search/rescue teams on that day. There were a lot of hereos that did/didn’t make it out of that rubble. I personally salute each and every one of them. I also thank the men and women in Afghanistan and Iraq. These people are protecting the freedoms that we take for granted and make us who we are. You are brave and we are proud.

Javascript Library Reviews

 

Well the hype of Web2.0 has certainly revitalized Javascript in the web development community.  Just when you think it’s dead…  I look forward to researching each of these libraries more thoroughly and then incorporate the best suited one into Kinetic CRM.

Here is the summary of the 4 main libraries as described by Sitepoint.

 

Dojo:

The great thing about Dojo is that it’s so rich in features. The Widget system provides a raft of useful controls such as a DatePicker, a RichText widget, as well as a considerable number of controls that you would expect to find in something like Microsoft’s MFC. In addition to this, you can build your own widgets on the framework using HTML, CSS and JavaScript (see this article for details).

But JavaScript need not be limited just to the browser, and Dojo is designed with this in mind. Dojo’s platform independence could make it an interesting platform for desktop widget development, as well as many other potential applications. As an example, Open Laszlo recently announced that it was licensing Dojo for its JavaScript implementation of the platform.

Dojo’s design has quite a Java-like aesthetic without trying to be Java. In fact, I’d say Dojo utilises JavaScript as a language exceptionally well. One downside of the library’s design, though, is the sometimes long package strings that you need to type out to call the methods or instantiate the library’s objects — it would be nice if Dojo could provide a way to “mix” a package into the global or local scope. This would provide ready access to a certain package if you planned on using a lot of methods from it, although I’m not sure how easily it could be incorporated.

Additionally, for all its features, Dojo is completely missing any functions that could aid the selection of DOM elements — something that’s quite fundamental to DOM Scripting. It seems to be quite a gaping hole in the library — it would be great to be able to select elements using CSS and/or XPath. Similarly, while some of the objects in the library seem to support a kind of iteration framework, Dojo is lacking in methods for iterating though arrays and collections, a task which seems to make up the bulk of DOM scripting tasks.
And at this point in time, documentation for Dojo is not at a premium. The official Dojo site contains some API documentation that’s far from complete, but it does have some well-written articles highlighting areas of the library. The JavaScript community has yet to embrace the daunting task of documenting Dojo, though, so independent on the topic articles are few and far between.

 

Mochikit:

First off, Mochikit’s logging framework is excellent. Simply add logging statements:

log("This is so much better than alert");
log("ERROR This thing is broke");

 

You can then use Mochikit’s bookmarklet to open a log window and view your log messages. You don’t need to add anything into your pages or include any extra script — it’s truly effortless and beats alert any day.

Mochikit also makes full use of JavaScript’s functional programming features to really enhance and simplify the library’s API. For instance, if you want to sort a group of objects by their name properties, you can use keyComparator to create the sort function for you:

var sortedByName = people.sort(keyComparator("name"));

 

There’s also the useful counter function. This creates a function which returns a value that’s incremented by one every time it’s called:

var nextId = counter();
nextId(); //=> 1 
nextId(); //=> 2 
nextId(); //=> 3

 

There’s also a full set of Python-style iteration functions, such as forEach, map and filter, which are sure to see heavy use.

As far as documentation goes, Mochikit has some very good API documentation, but details on some very basic parts of the library are a little lacking. In particular, after reading all the docs, watching the screencast and writing a few Mochikit-based scripts, I’m still unsure which version of the library is best suited for any purpose. Do I use the packed version or the main Mochikit.js? How can I load individual parts of the library?
However, Mochikit does have a mailing list, so answers to these kinds of questions are, no doubt, not far away. All in all, Mochikit may not be what you’re used to in terms of a JavaScript library, but it’s beautifully designed and I’m looking forward to seeing where Bob takes it.

 

Prototype/Script.aculo.us:

Convenience is king with Prototype. Most notably, the $ function (which selects elements by id) and the $$ function (which selects elements using CSS selectors) provide extremely quick access to elements on the page. The $$ function even supports CSS3 selectors — most browsers don’t. When you use it in conjunction with the enumerable methods and Prototype’s other convenience methods, you can come up with some pretty concise statements. For instance, to hide all div elements with a class of /#c#”obscene”:

$$("div.obscene").map(Element.hide);
$$("a[href='http://']").each(function(element)
 {
   Event.observe(element, 'click', openNewWindow);
 }
);

 

As we all spend most of our scripting time working through lists of DOM nodes, this buys us a lot of power indeed. The compact and intuitive API really is the killer feature of Prototype for me.

Scriptaculous is a great, extensive effects library with solid drag-and-drop support that, again, is ridiculously easy to use. Consider this:

new Draggable('my_element');

 

This produces an element that the user can drag. You can then add further configuration using object notation, like this:

new Draggable('my_element',
 {
   revert : true
 }
);

 

Documentation was very limited for a long time, but recently many people have filled the gap, making Prototype one of the most widely documented of the big JavaScript libraries, albeit that that documentation is a bit splintered. There are no central API docs, but there’s a whole raft of libraries that cover parts of the library, as well as Jonathan Snook’s excellent cheat sheet detailing the entire library. The prototypedoc.com site also maintains a pretty thorough list of articles about Prototype to help you get started with the library.

 

Yahoo UI Library:

The documentation provided by Yahoo! for the library is excellent. The site has formal API documentation, plenty of examples, a mailing list and some brief but clear explanations of the main features of each part of the library. However, as with Dojo and Mochikit, the library has not quite managed to capture the imagination of the developer community as much as Prototype, so independent articles are still thin on the ground at the moment. The best place to check for articles about YUI is Yahoo! developer, Dustin Diaz’s site .

As I implied above, the event handling implementation is one of YUI’s main strengths, and the fact that it is decoupled from the other parts of the library means that it could well see a lot of use independently from the rest of the library. However, the rest of the library, while being very functional, doesn’t contain as many innovative features as the likes of Mochikit, Dojo and Prototype, and because of the long package strings, coding with YUI sometimes feel rather long-winded.

Yet the growing list of components is very rich. For instance, the Calendar component supports several languages and multiple date selections, and the Container classes give you the power to implement all kinds of windowed interfaces. One downside of using these components is that they tend to be very heavily dependent on the other libraries; in discussing this, Dean Edwards highlights as an example the treeview control, which uses around 260K of JavaScript.

 

So Who Wins?

Well, the short answer to this question is that there is no real stand-out solution that excels in all situations.

Prototype is the most comprehensively documented — albeit in a splintered way. It is also seemingly the most widespread library at the moment, possibly because it really excels at the kind of tasks developers complete most often, like selecting nodes and working with lists. Of course, it’s going to be the natural choice for Ruby developers because it sticks to many Ruby idioms. One other great thing about Prototype is that it has the mighty weight of Rails behind it and, as a result, there are many developers providing bug fixes and patches to Prototype. Finally, it offers a wealth of add-on libraries such as scriptaculous, Rico, and Behaviour that make it a good, solid choice for many developers.

On the other hand, Prototype has a very under-developed event handling framework, which is a major problem for an otherwise powerful library. Also — and this is purely a matter of taste — Prototype’s super-pragmatic approach to things (like the heavy use of the innerHTML property) can seem a little “dirty” sometimes.

For smaller projects, the decoupled design and fully-featured components of YUI may well be a big plus. It’s very easy to drop in the Connection Manager or the Event library and get going on some basic tasks without having to traverse too much of a learning curve. On the whole, though, it doesn’t have much to offer in terms of cool or powerful features.

Dojo is definitely the daddy of the bunch — you can almost always rely on it for the most powerful implementation of any feature. And Dojo’s focus on performance is an absolute godsend if you’re planning a very JavaScript-intensive application. The widget implementation also has enormous potential for building complex UIs. However it really is quite big — both in terms of its file size and the size of the API — so I wouldn’t recommend it for smaller projects.

In my opinion, Mochikit is by far the most well designed and well thought out of the four, and Python/Twisted/Nevow developers will definitely find its API very familiar. However, its documentation is a bit thin in some places (for instance, I’m still a little unsure as to which version of the Mochikit distribution to put in the script tag). Also, some of the idioms and functional techniques that it uses may be confusing for beginners or those who aren’t well versed in functional programming techniques. However, it really is worth a look. Mochikits’s capabilities will probably surprise you — the createDOM function, iteration tools and the asynchronous architecture are a work of art.