Domain-Genie™ Create New Infomercial Domain Names

• Download DomainGenie - 663 KB

Introduction

Everyone knows how hard it can be to create a new domain name and in business today you must have a good domain name. I produce half hour TV infomercials hosted by famous celebrities to sell a variety of products from diets to software. Every time I create a new TV infomercial selling a new product I have to create a new domain name for that product. As most readers know, all the good domain names are already taken.

Since one infomercial will gross from $20 million to $300 million from TV sales alone in one year, it is extremely important to get an easy-to-remember domain name. A domain name can make or break an infomercial and this also applies to many other online businesses. Many TV viewers look for a website based on the product name. For example, if the product name were "Domain-Genie" they would automatically assume the domain name is www.Domain-Genie.com so we always try to make the name of the product on an infomercial the domain name for the infomercial.

In this article I will present one approach to creating good infomercial domain names that are still avaialble that attempts to both generate good domain names and to check those names for availability. Since ICANN doesn't allow you to run scripts for checking domain availability against their servers I decided to use DNS checks that don't access ICANN servers. My approach only gives you an approximate idea of which names are available but it helps to whittle down the lists you create.

Background

Let me here some credit to two other authors here. In order to handle the DNS queries I used the code from an article here on CodeProject called DNS.NET Resolver to analyze the DNS packets. And the tab control I used is also from an article here on CodeProject called A Highly Configurable MDI Tab Control from Scratch to create the tabs for the WhoisForm and DictionaryForm in the project with this article. The first part is to generate new domain names and they to check to see if that domain name is registered and trademarked. ANd I used a modified version of a word generator from another article here on CodeProject, namely, Creating a Nickname Generator by Juraj Borza.

Alliteration & Rhyme Make Good Domain Names

Short, sweet, simple, and easy-to-remember is the key to a good domain name. So what makes a name easy to remember? A word or phrase is easy to remember if the word has a visual association. For example, the word "cat" is easy to remember because when you see this word you can easily visualize a cat. On an infomercial we show a visual association with the product and domain name so TV viewers can more easily remember the name.

Alliteration is where you have two or more stressed syllables of a word group either with the same consonant sound or sound group (consonantal alliteration), as in from stem to stern, or with a vowel sound that may differ from syllable to syllable (vocalic alliteration), as in each to all. In incorprated in the sample project alliteration using matching first letters and I plan on adding in the next update an algorithm for consonantal alliteration which should help a lot in creating more pleasing sounding names.

So how do we create a good domain name programatically? In Domain-Genie I use a two-phrase system as shown in the diagram below.

The idea is that we will create two phrases, namely, Phrase #1 and Phrase #2. Each phrase can be drawn from a variety of sources such as:

• A Fixed Word
• Lists of specialized Words
• Language Dictionaries
• Randomly Generated Letters

Then you can select to juxtapose the two pharses with no dash or you can include a dash between the juxtaposition of the two pharses. There is an option to use "Aliteration" which allows you to force the first letter of the Phrase #1 to match the first letter of Phrase #2. One of the hardest things is finding good specialized word lists that are free and I would welcome any tips from readers who may know where such word lists might be found on the Internet? The program allows you to set teh maximum length of each of the the two phrases.

I included in the program lists of words that fall into certain categories. It was pretty hard to find these word lists on the Internet and I am still looking for additional word lists. The word lists I included are shown below.

Logic For Testing Domain Name Availability

Below is the cod efor the thread and logic I used to see if the domain name is available. As I stated, this is a very rough way of guessing at availability and it generates false positives. A domain that is registered many not have any name server and a domian with a name server may be available under certain conditions. But it gives you a way of getting a quick read on thousands of domain names quickly. The logic I used can be seen below and availability is stored in the variable _Status.

private void DoWhoisQuery(object o)
{
   object[] state = (object[])o;
   int _Row = (int)state[0];
   string _Domain = (string)state[1];
   string _Server = (string)state[2]; 
   string _Status = "registered";
   string _DStatus = "unknown";
   string _Info = string.Empty;
   int iAnswerCount = -1;
   StringBuilder sb = new StringBuilder();
   Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US", false);
   Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US", false);
   Stopwatch sw = new Stopwatch();
   sw.Start();
   Response response = resolver.Query(_Domain, QType.ANY, QClass.IN);
   sw.Stop();
   bool bError = false;
   if (response.Error != "")
   {
      sb.Append(response.Error.ToString());
      iAnswerCount = -1;
      _Status = "unknown";
      _DStatus = "-1";
      _Info = "none";
      bError = true;
   }
   if(!bError)
   {
      iAnswerCount = response.header.ANCOUNT;
      if (iAnswerCount < 1)
         _Status = "available?";
      if (iAnswerCount > 1)
         iAnswerCount = 0;
      sb.Append("Got answer:");
      sb.Append("<br />");
      sb.Append(string.Format("->>HEADER<<- opcode: {0}, status: {1}, id: {2}", 
      response.header.OPCODE, response.header.RCODE, response.header.ID));
      sb.Append("<br />");
      sb.Append(string.Format("flags: {0}{1}{2}{3}; QUERY: {4}<br />, 
      ANSWER: {5}<br />, AUTHORITY: {6}<br />, ADDITIONAL: {7}<br />",
      response.header.QR ? " qr" : "",
      response.header.AA ? " aa" : "",
      response.header.RD ? " rd" : "",
      response.header.RA ? " ra" : "",
      response.header.QDCOUNT,
      response.header.ANCOUNT,
      response.header.NSCOUNT,
      response.header.ARCOUNT));
      sb.Append("<br />");
      if (response.header.QDCOUNT > 0) {
         sb.Append("QUESTION SECTION:");
         foreach (Question question in response.Questions)
         sb.Append(string.Format("{0}", question));
         sb.Append("<br />");
      }
      if (response.header.ANCOUNT > 0) {
         sb.Append("ANSWER SECTION:");
         foreach (AnswerRR answerRR in response.Answers)
         sb.Append(answerRR);
         sb.Append("<br />");
      }
      if (response.header.NSCOUNT > 0) {
         sb.Append("AUTHORITY SECTION:");
         foreach (AuthorityRR authorityRR in response.Authorities)
            Console.WriteLine(authorityRR);
         sb.Append("<br />");
      }
      if (response.header.ARCOUNT > 0) {
         sb.Append("ADDITIONAL SECTION:");
         foreach (AdditionalRR additionalRR in response.Additionals)
            sb.Append(additionalRR);
         sb.Append("<br />");
      }
      sb.Append(string.Format("Query time: {0} msec", sw.ElapsedMilliseconds));
      sb.Append("<br />");
      sb.Append(string.Format("SERVER: {0}#{1}({2})", response.Server.Address, 
      response.Server.Port, response.Server.Address));
      sb.Append("<br />");
      sb.Append(string.Format("WHEN: " + response.TimeStamp.ToString(
      "ddd MMM dd HH:mm:ss yyyy", new System.Globalization.CultureInfo("en-US"))));
      sb.Append("<br />");
      sb.Append(string.Format("MSG SIZE rcvd: " + response.MessageSize));
      sb.Append("<br />");
   }
   try
   {
      ThreadSync.InvokeDelegate( QueryComplete, this, new CellUpdateEventArgs( 
    _Row, _Domain, _Server, _Status, _DStatus, sb.ToString()));
   }
   catch (SystemException e)
   {
      throw e;
   }
   catch (Exception e)
   {
   } 
}

Virtual ListViews for Language Dictionaries

Another useful approach is to use language dictionaries. In the next update I will post full language dictionaries for 77 languages. Because of the large numbers of words per language I used virtual listviews for loading the large language dictionaries and I loaded the virtual views as follows:

        void</span /> SetupListview(bool</span /> blnVirtual)
        {
            //</span /> Force it to be virtual
</span />            blnVirtual = true</span />;
            this</span />.listViewWords.VirtualMode = false</span />;
            this</span />.listViewWords.View = View.List;
            this</span />.listViewWords.CheckBoxes = true</span />;

            if</span /> (blnVirtual)
            {
                //</span /> This makes it real fast!!
</span />                this</span />.listViewWords.RetrieveVirtualItem += new</span /> RetrieveVirtualItemEventHandler(listView_RetrieveVirtualItem);
                this</span />.listViewWords.VirtualListSize = lvi.Length;
                this</span />.listViewWords.VirtualMode = true</span />;

                //</span /> This is for drawing unchecked checkboxes
</span />                this</span />.listViewWords.OwnerDraw = true</span />;
                this</span />.listViewWords.DrawItem += new</span /> DrawListViewItemEventHandler(listView_DrawItem);

                //</span /> Redraw when checked or doubleclicked
</span />                this</span />.listViewWords.MouseClick += new</span /> MouseEventHandler(listView_MouseClick);
                this</span />.listViewWords.MouseDoubleClick += new</span /> MouseEventHandler(listView_MouseDoubleClick);
            }
            else</span />
            {
                listViewWords.Items.AddRange(lvi);
            }
        }

Random Letter Phrases

The option to "Generate Random Letters" for a Phrase uses the approach developed by Juraj Borza in his CodeProject article, Creating a Nickname Generator, that I referred to above, namely that random strings like tmxoit, rdyari, qefoauh, uatyni would not be good names and would create names hard to memorize. I used his suggestion to alternate vowels and consonants, so we will get results like Zobona, Osavir, Ecumol, or Obunu as he discusses in his artcile and shown below.

        public</span /> NameGenerator()
        {
            random = new</span /> Random();
            vowels = new</span /> char</span />[] { '</span />a'</span />, '</span />e'</span />, '</span />i'</span />, '</span />o'</span />, '</span />u'</span />, '</span />y'</span /> };
            consonants = new</span /> char</span />[] { '</span />b'</span />, '</span />c'</span />, '</span />d'</span />, '</span />f'</span />, '</span />g'</span />, '</span />h'</span />, '</span />j'</span />, '</span />k'</span />, '</span />l'</span />, '</span />m'</span />,
            '</span />n'</span />, '</span />p'</span />, '</span />q'</span />, '</span />r'</span />, '</span />s'</span />, '</span />t'</span />, '</span />v'</span />, '</span />w'</span />, '</span />x'</span />, '</span />z'</span /> };
        }

        public</span /> string Generate(int</span /> length, string startsWith)
        {
            StringBuilder sb = new</span /> StringBuilder();
            //</span />initialize our vowel/consonant flag
</span />            bool</span /> flag = (random.Next(2</span />) == 0</span />);
            for</span /> (int</span /> i = 0</span />; i <</span /> length; i++)
            {
                sb.Append(GetChar(flag));
                flag = !flag; //</span />invert the vowel/consonant flag
</span />            }
            return</span /> startsWith+sb.ToString();
        }

Trademark & Google Searches

I also included a Multi-Tabbed Web Browser to allow users to Google names and to do trademark searches on the available domain names they created. I tried to automate the trademark searches but you aren't allowed to run a script against the site so these searches msut still be done manually.

Points of Interest

Can An Infomercial Make A Domain Name Famous? The answer is NO. It still takes an easy-to-remember name or no amount of TV exposure will make it famous. It is interesting to note that studies have shown that after 90 days of airing an infomercials that 95% of the viewing public will have seen the infomercial at least once. But even with that level of exposure TV viewers will only remember the product or domain name if it can be associated with some visual image and it is also easy to remember. For those readers who might be curious, a half hour TV infomercial can send 1,000 unique visitors to a website per $1 of TV time. The simple fact is that anybody can videotape and air their own infomercials since home video cameras are broadcast quality (they all meet CRC-601 specs) and a half hour of TV time can be bought for as little as $15 on any TV network. Most people confuse the terms TV Spot and Infomercial. A TV Spot is 2 minutes or less and an Infomercial is a 26 minutes or longer in length. This distinction is important because when a TV spot comes on TV people get up to go to the bathroom or refrigerator or they TIVO out spots. And a half hour of infomercial time costs LESS than a 60-second TV Spot which is surprising to most people.

In Conclusion

In conclusion, it has become a necessity to have a website for your business nowadays with a good domain name. In general in order to create a good domain name it should be memorable, short, dot com, global, nice sounding, hyphen free, aliterate, descriptive, and it should also brand your product. The name should go automatically to visitors mind and should be easy to memorize. So in creating word lists for this program you should include only words that are memorable. The shorter the name the better. That is why I included in the sample program to set the length of the phrase. Shorter domains reduce the possibility of spelling mistakes and visitors are more likely to type a shorter domain name.

Try to stick with only the dot com suffix. Aliterate words that ryhme sound nicer and are easier to pronunce, to memorize and to spell. Your domain name should describe the website activity so visitors know immediately what the website is about. And your domain name should be a global name so visitors from different countries, races and religions can relate to it. Global name seems more elegant and attract more visitors. When using this program to generate new domain names I found that creating and tesing a few hundred at a time seems to work best. In addition, using aliteration helps to generate more pleasing sounding domain names.

Bill SerGio, The Infomercial King
www.GeminiGroupTV.com
www.StationBreak.net