Listing my blog on Technorati and TopOfBlogs

Note from the blog owner: This article is outdated; it is kept here for historical reasons.

Yanniel's notes is now alive in Technorati and TopOfBlogs. Both sites give authentic backlinks to your blog, as they don't implement the rel=”nofollow” attribute in the HTML <a ... tag.

Technorati is a blog search engine and directory, which in my humble opinion is very professional and well established. In fact, I prefer to use Technorati rather than Google Blog Search to browse and search the blogosphere. The bad thing about Technorati is that it only allows blogs in English.

TopOfBlogs is a blog directory that has gained strong popularity lately. It ranks the blogs according to several variables, which converge in a general rank value for each blog. TopOfBlogs is far from been as professional as Technorati, but it covers all languages and cultures.

Both sites perform a manual revision of each blog you claim (submit). The purpose is to fight spam and to allow only authentic content to be listed. Of course, spammers are quite smart these days and the battle cannot be won just by the initial moderators' revision.

There's much more about  Technorati and TopOfBlogs. I intend to talk about them in further posts.

I just registered a new domain for my blog at Dynadot

I decided to move away from Blogger's free hosting service and get me a custom domain. Although you can register a domain from within Blogger, I decided to use a different domain name registrar: Dynadot.

”Dynadot is an ICANN accredited domain name registrar ” which I have used in the past with no complaints. It has a bunch of cool features like:
  • Domain search (extended to premium domain search if desired).
  • Domain suggestion (great if you haven't decided the name of your domain yet )
  • Domain privacy (this is what you need if you intend to high your identity as owner of the domain)
  • Lots of payment methods (Credit Cards, PayPal, MoneyBookers and more...)
I wanted a generic domain name for my blog (not a .cu, .ca, .us domain). So, my initial ideas were,, and

After a quick search, I decided to buy because it was cheaper and at the end, this blog is all about me. So, (standing for Yanniel's information) is pretty much what I wanted.

One observation, the domains bought at Dynadot are cheaper than the ones you buy directly from within Blogger. Blogger charges you with $10 (USD) annually, and a I got my domain just for $5.75 (USD).

In the picture below you can see the Dynadot domain search interface:

Domain's search at Dynadot

Once you have added your domains to cart, you are prompted to log-in (or register) as a Dynadot's user. This is indispensable to configure your domains later. I expect to replace my current sub-domain with ASAP. I guess at that point I will write a new post to explain how to set up a Blogger 's blog using a Dynadot registered domain.

Using Macros in Delphi

Computer programmers often need to transform a piece of code in a repetitive way. For example, consider transforming the following fields declaration into a fields initialization [1], as shown below:

Delphi macros to transform source code

You can do that by hand of course, but you can also use macros to streamline your work, specially if you need to convert more than just a few lines of code.

Macros allow to record a sequence of keystrokes and playback such compilation with just one saved keystroke.

To record a macro in Delphi you need to:
  1. Press Ctrl + Shift + R to start recording your macro. [2]
  2. Use as many keystrokes as you want to transform your code.
  3. Press Ctrl + Shift + R (again) to finish recording your macro. [3] 
To playback a saved (recorded) macro you just need to press Ctrl + Shift + P each time you want to run it. [4]

At this point you might be a little lost, hopefully the following video will clarify all your doubts:

In the previous example I recorded (and played) a macro containing 20 steps (keystrokes), but I am sure you can do the same with less keystrokes. If you do, please, write you keystrokes in the comments section at the bottom of this post.  

In conclusion, macros can make your life easier when writing code; besides, you can use them to impress your boss or colleagues with your super fast typing skills ;-)

[1]: The unit containing the full source code of this example is at the end of this post.
[2]: In the latest Delphi versions you can click the following button to Record Macro:
Record Macro button in Delphi
[3]: In the latest Delphi versions you can click the following button to Stop Recording Macro:
Stop Recording Macro button in Delphi
[4]: In the latest Delphi versions you can click the following button to Playback Macro:
Playback Macro button in Delphi
Source code:

unit Person;


  TPerson = class
    FGivenName: string;
    FFamilyName: string;
    FPhoneNumber: string;
    FDateOfBirth: TDateTime;
    FAddress: string;
    FEMail: string;
    constructor Create(aGivenName, aFamilyName, 

                       aPhoneNumber: string;
                       aDateOfBirth: TDateTime;
                       aAddress, aEMail: string);
    //Other methods and properties here...


{ TPerson }

constructor TPerson.Create(aGivenName, aFamilyName, 

                           aPhoneNumber: string;
                           aDateOfBirth: TDateTime; 

                           aAddress, aEMail: string);
  FGivenName:= aGivenName;
  FFamilyName:= aFamilyName;
  FPhoneNumber:= aPhoneNumber;
  FDateOfBirth:= aDateOfBirth;
  FAddress:= aAddress;
  FEMail:= aEMail;

  //Step  1: Ctrl + Shift + ArrowRight
  //Step  2: Ctrl + C
  //Step  3: ArrowLeft
  //Step  4: =
  //Step  5: Spacebar
  //Step  6: Ctrl + V
  //Step  7: Ctrl + ArrowLeft
  //Step  8: a
  //Step  9: Del
  //Step 10: Ctrl + ArrowRight
  //Step 11: Ctrl + ArrowRight
  //Step 12: Ctrl + Shift + ArrowLeft
  //Step 13: Backspace
  //Step 14: Backspace
  //Step 15: Backspace
  //Step 16: Backspace
  //Step 17: ;
  //Step 18: Ctrl + ArrowLeft
  //Step 19: Ctrl + ArrowLeft
  //Step 20: ArrowDown;