Yanniel's notes

How to open a checking account at ING DIRECT

2013-04-07T23:38:00.001-04:00

Everything at ING DIRECT is done online… opening a checking account is no different: you can do it in 10 minutes (at the most) from the comfort of your home computer while you are in your pyjamas. What I have found so far about ING DIRECT is that all procedures can be done with an extreme simplicity and from the comfort of your home.

ING DIRECT calls its checking account: THRiVE Chequing Account. Why THRiVE? I guess because this THRiVE Chequing allows your money to thrive, to develop, to grow…

Most checking accounts in Canadian banking institutions charge you a monthly fee. This is ridiculous if you ask me: banks are profiting from our own money, but that’s not enough for them: they still charge us a monthly fee for having our own money within their grasp, money from which they are profiting already.

This is what THRiVE Chequing at ING DIRECT has to offer:

NO MONTHLY FEES. Ask yourself if your current bank charges you a monthly fee and ask yourself if you should be paying for it?
Unlimited transitions: once again, you can perform unlimited transitions at ING DIRECT for free.
Earn interest on the money you put on your THRiVE Chequing Account (yes, you heard well: this is a checking account that pays interest, just as saving accounts do).

I am not going to load you with more details…if you want to know more about the benefits of opening a THRiVE Chequing Account with ING DIRECT come here: http://www.ingdirect.ca/en/chequing/

Now, in order to open a THRiVE Chequing Account with ING DIRECT you have to do only TWO things:

Complete an online form that won’t take you more than 10 minutes. I am not exaggerating: this form won’t take you more than 10 minutes to fill. In order to fill the form click here: Open new THRiVE Chequing Account at ING DIRECT.
Write your initial deposit cheque (payable to yourself) for at least $100, and mail it to ING DIRECT, 111 Gordon Baker Road, Toronto, Ontario, M2H 3R1. Note: all new clients of ING DIRECT opening accounts for at least $100 box get a $50 bonus. What does this means? It means that you open your account with $100, but you are credited with $150; so ING DIRECT welcomes you with $50 box.

That’s all: by completing the two steps above you will open a THRiVE Chequing Account at ING DIRECT, that will treat you with unlimited transactions, no monthly fees, fair saving interests and a $50 box welcome gift.

If you have any questions, drop a line in the comments section below. I’ll do my best to answer.

If you think this post might be useful to someone else, don’t hesitate in recommending by clicking the Google Plus (G+) button at the beginning of the post. Thanks!

Enabling TLang to handle more than 17 translations: a workaround for a regression bug in Delphi XE3

2013-01-13T20:21:00.003-05:00

I recently had to localize a FireMonkey application and for that I aimed to use the TLang component. With TLang you can define a collection of native strings to be localized and the corresponding translations to a particular language. To my surprise the component was allowing to store a maximum of 17 translations for the whole application. So, what about the other strings that need localization?

It seems there’s a regression issue from Delphi XE2 to Delphi XE3 that is preventing TLang to store more than 17 translations. You can even find an entry for this in Embarcadero Quality Central, for which no workaround or fix has been provided up to this date.

I found a programmatic workaround for this issue. Basically, the native strings and the translations could be loaded from text files in which each line will have the form:

NativeString1=Translation1
NativeString2=Translation2
NativeString3=Translation3
…………
NativeStringN=TranslationN

You will need one file containing the native strings and the translations per language. These files can contain as many lines as you which (certainly more than 17). In order to load those files into an existing TLang component you can use the function below:

procedure LoadTranslationsFromFile(aLangCode: string; aFileName: string; aLang: TLang);
var
  Translations: TStrings;
begin
  if (aLangCode <> '') and
     (FileExists(aFileName)) and
     (Assigned(aLang)) then
  begin
    Translations:= TStringList.Create;
    Translations.LoadFromFile(aFileName);
    aLang.Resources.AddObject(aLangCode, Translations);
  end;
end;

For an example of how to use such function see below:

procedure TForm1.Button1Click(Sender: TObject);
begin
  LoadTranslationsFromFile('ES', 'C:\Temp\Lang_Test_ES.txt', Lang1);
  LoadTranslationsFromFile('EN', 'C:\Temp\Lang_Test_EN.txt', Lang1);
end;

Hopefully this bug will be fixed in the near future; but meanwhile you can use this workaround to handle more than 17 translations with the TLang component.

Refactoring to patterns. Yet another TDD example coded in Delphi

2012-12-17T10:47:00.002-05:00

Long overdue here is my second article about Test Driven Development (TDD) in Delphi. This is a continuation of TDD in Delphi: The Basics, another post that I wrote a few months earlier.

I would like to focus in a particular step within the TDD cycle: refactoring the code. Refactoring means optimizing, cleaning, shortening, beautifying, styling (put your own word here) the code without breaking the functionality; that is, without breaking your unit tests.

By having unit tests in place before refactoring, you guarantee that the changes to the code are safe. Refactoring can introduce bugs. To avoid those bugs you need your unit tests in place.

Refactoring can introduce something else: refactoring can introduce design patterns into your code. That means you don’t have to introduce the design patterns up-front, since your code can evolve from a “very rustic implementation” to a “pattern oriented implementation”. This is referred as “refactoring to patterns”. If you are interested on the topic, I advise you to read Refactoring To Patterns by Joshua Kerievsky.

I’ll take the chess game as the base to my example. For simplicity, I’ll just refer to a couple of pieces: the knight and the bishop. In this example, I will just focus in refactoring some code with unit tests already in place. A detailed walk-through for the TDD cycle can be found in my previous article, which is also based on the chess game.

The code is easy enough to be self-explanatory: basically, there is a class hierarchy in which TPiece is the base class from which TKnight and TBishop derive. Take a quick look:


unit ChessGame;

interface

type

 TPiece = class
 private
   FX,
   FY: Byte;
 public
   constructor Create(aX, aY: Integer);
   function IsWithinBoard(aX, aY: Integer): Boolean;
 end;

 TBishop = class (TPiece)
 public
   function CanMoveTo(aX, aY: Byte): Boolean;
   function isValidMove(aX, aY: Byte): Boolean;
 end;

 TKnight = class(TPiece)
  public
    function CanMoveTo(aX, aY: Byte): Boolean;
    function isValidMove(aX, aY: Byte): Boolean;
 end;


implementation

{ TPiece }

constructor TPiece.Create(aX, aY: Integer);
begin
  inherited Create;
  // TODO: check that this assignment is valid.
  // Not now, ok? :-)
  FX:= aX;
  FY:= aY;
end;

function TPiece.IsWithinBoard(aX, aY: Integer): Boolean;
begin
  Result:= (aX > 0) and
           (aX < 9) and
           (aY > 0) and
           (aY < 9);
end;

{ TKnight }

function TKnight.isValidMove(aX, aY: Byte): Boolean;
var
  x_diff,
  y_diff: Integer;
begin
  x_diff:= abs(aX - FX) ;
  y_diff:= abs(aY - FY) ;

  Result:= ((x_diff = 2) and (y_diff = 1))
                         or
           ((y_diff = 2) and (x_diff = 1));
end;

function TKnight.CanMoveTo(aX, aY: Byte): Boolean;
begin
  Result:= IsWithinBoard(aX, aY) and
           IsValidMove(aX, aY);
end;

{ TBishop }

function TBishop.isValidMove(aX, aY: Byte): Boolean;
begin
  Result:= abs(aX - FX) = abs(aY - FY);
end;

function TBishop.CanMoveTo(aX, aY: Byte): Boolean;
begin
  Result:= IsWithinBoard(aX, aY) and
           IsValidMove(aX, aY);
end;

end.

/////////////////////////////////////////////

 

unit TestChessGame;

interface

uses
  TestFramework, ChessGame;

type
  // Test methods for class TPiece
  TestTPiece = class(TTestCase)
  strict private
    FPiece: TPiece;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestIsWithinBoard;
  end;

  // Test methods for class TBishop
  TestTBishop = class(TTestCase)
  strict private
    FBishop: TBishop;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestCanMoveTo;
    procedure TestisValidMove;
  end;

  // Test methods for class TKnight
  TestTKnight = class(TTestCase)
  strict private
    FKnight: TKnight;
  public
    procedure SetUp; override;
    procedure TearDown; override;
  published
    procedure TestCanMoveTo;
    procedure TestisValidMove;
  end;

implementation

procedure TestTPiece.SetUp;
begin
  FPiece := TPiece.Create(4, 4);
end;

procedure TestTPiece.TearDown;
begin
  FPiece.Free;
  FPiece := nil;
end;

procedure TestTPiece.TestIsWithinBoard;
begin
  //Test trivial (normal) workflow
  Check(FPiece.IsWithinBoard(4, 4));

  //Tests boundaries
  Check(FPiece.IsWithinBoard(1, 1));
  Check(FPiece.IsWithinBoard(1, 8));
  Check(FPiece.IsWithinBoard(8, 1));
  Check(FPiece.IsWithinBoard(8, 8));

  //Test beyond the boundaries
  CheckFalse(FPiece.IsWithinBoard(3, 15));
  CheckFalse(FPiece.IsWithinBoard(3, -15));
  CheckFalse(FPiece.IsWithinBoard(15, 3));
  CheckFalse(FPiece.IsWithinBoard(15, 15));
  CheckFalse(FPiece.IsWithinBoard(15, -15));
  CheckFalse(FPiece.IsWithinBoard(-15, 3));
  CheckFalse(FPiece.IsWithinBoard(-15, 15));
  CheckFalse(FPiece.IsWithinBoard(-15, -15));
end;

procedure TestTBishop.SetUp;
begin
  FBishop := TBishop.Create(4, 4);
end;

procedure TestTBishop.TearDown;
begin
  FBishop.Free;
  FBishop := nil;
end;

procedure TestTBishop.TestCanMoveTo;
begin
  // Hey developer, indulge me here: believe
  // that I fully wrote the code for this
  // test already before writing anything else.
end;

procedure TestTBishop.TestisValidMove;
begin
  // Hey developer, indulge me here: believe
  // that I fully wrote the code for this
  // test already before writing anything else.
end;

procedure TestTKnight.SetUp;
begin
  FKnight := TKnight.Create(4, 4);
end;

procedure TestTKnight.TearDown;
begin
  FKnight.Free;
  FKnight := nil;
end;

procedure TestTKnight.TestCanMoveTo;
begin
  // Hey developer, indulge me here: believe
  // that I fully wrote the code for this
  // test already before writing anything else.
end;

procedure TestTKnight.TestisValidMove;
begin
  // Hey developer, indulge me here: believe
  // that I fully wrote the code for this
  // test already before writing anything else.
end;

initialization
  // Register any test cases with the test runner
  RegisterTest(TestTPiece.Suite);
  RegisterTest(TestTBishop.Suite);
  RegisterTest(TestTKnight.Suite);
end.

Note that the method CanMoveTo is duplicated in both TKnight and TBishop; that’s not nice isn’t it? In order to fix this, we can pull-up the CanMoveTo method to the TPiece base class. Note this now: the CanMoveTo has now become a “template method”; because is a general algorithm applicable to all kind of chess pieces (TKnight ,TBishop, etc) .

This general algorithm has deferred some steps to be implemented in the subclasses; I mean, the isValidMove method is still coded in the subclasses. Isn’t this a beauty? You have now refactored your code and when doing so, you have introduced the Template Method Design Pattern.

What’s even best, (don’t forget this because it is a key part): is that we can guarantee that our fancy refactoring didn’t break our pre-existing functionality. Why? Because we had unit tests in place written a long time ago. Writing unit test from the beginning gives a huge peace of mind to the developer :-) See the new refactored code below:


unit ChessGameRefactored;

interface

type

 TPiece = class
 private
   FX,
   FY: Byte;
 public
   constructor Create(aX, aY: Integer);
   function IsWithinBoard(aX, aY: Integer): Boolean;

   function CanMoveTo(aX, aY: Byte): Boolean;
   function isValidMove(aX, aY: Byte): Boolean; virtual; abstract;
 end;

 TBishop = class (TPiece)
 public
   function isValidMove(aX, aY: Byte): Boolean; override;
 end;

 TKnight = class(TPiece)
  public
    function isValidMove(aX, aY: Byte): Boolean; override;
 end;


implementation

{ TPiece }

constructor TPiece.Create(aX, aY: Integer);
begin
  inherited Create;
  // TODO: check that this assignment is valid.
  // Not now, ok? :-)
  FX:= aX;
  FY:= aY;
end;

function TPiece.IsWithinBoard(aX, aY: Integer): Boolean;
begin
  Result:= (aX > 0) and
           (aX < 9) and
           (aY > 0) and
           (aY < 9);
end;

function TPiece.CanMoveTo(aX, aY: Byte): Boolean;
begin
  Result:= IsWithinBoard(aX, aY) and
           IsValidMove(aX, aY);
end;

{ TKnight }

function TKnight.isValidMove(aX, aY: Byte): Boolean;
var
  x_diff,
  y_diff: Integer;
begin
  x_diff:= abs(aX - FX) ;
  y_diff:= abs(aY - FY) ;

  Result:= ((x_diff = 2) and (y_diff = 1))
                         or
           ((y_diff = 2) and (x_diff = 1));
end;

{ TBishop }

function TBishop.isValidMove(aX, aY: Byte): Boolean;
begin
  Result:= abs(aX - FX) = abs(aY - FY);
end;

end.

Conclusion, in addition to all the cool things of TDD there’s the possibility of refining your design not up-front, but when refactoring your code. Design patterns can be introduced at any time and we know that such introduction, if late, is not going to break our logic, because we have unit tests in place to prevent that from happening.

Some related reading below:

What types of mobile phones are used in Cuba?

2012-10-03T20:36:00.002-04:00

All mobile phones in Cuba are linked together by a GSM cellular network, operating in the 900MHz band throughout the island.

The 850MHz band is also operational in selected locations, namely: Havana City, Varadero, Cayo Coco and Cayo Guillermo.

If you were to buy a cell phone for a person living in Cuba: I would recommend acquiring an unlocked quad-band phone (GPRS compatible).

It is important for the cellular phone to be unlocked; otherwise it won’t work with the Cuban mobile operator: Cubacell. Of course, a locked phone could be unlocked, but why to bother? You can buy a brand new unlocked phone and you will save the money and the time for unlocking it after.

Quad -band phones operate in the four major GSM bands: 850, 900, 1800 y 1900 MHz. With this kind of phone you will be able to get mobile coverage in the whole island. Technically speaking you don’t need the 1800 and 1900 MHz bands in Cuba, but it does not hurt to have them as well.

One final tip: the MMS service is available in Cuba. Most people don’t know this. This service allows you to send multimedia messages containing text, images, audio y video to a Cuban cell phone. Now, in order to use this service, your cell should support GPRS technology. Note that not all GSM mobile phones support GPRS technology. It depends on the model, brand and year of production.

The MMS service is not activated by default. In order to use it, you should activate the service following these steps (in Spanish).

I have listed below a selection of phones that you can buy trough Amazon. All these phones are unlocked, quad –band (GSM) and GPRS compatible. These phones will work in Cuba. Amazon is a trustable online retailer, probably the largest and better known in the world. So buying through Amazon is safe and painless.

Motorola (More cells from Motorola...)

Sony Ericsson (More cells from Sony Ericsson...)

Nokia More cells from Nokia...

If you cannot find the cell phone you are looking for in the list above, then you might try the search box just below:

Amazon.com Widgets

Since you are reading this article you might be interested in knowing how to recharge the cell phone of a person living in Cuba over the internet. Check it out!

Make payments to your Brick Platinum Card from TD EasyWeb

2012-09-23T23:32:00.003-04:00

You can use TD EasyWeb, the online banking system of TD Canada Trust, in order to make payments or contributions to your Brick Platinum card. For that, you need to add your Brick Platinum Card as a new payee in your EasyWeb account.

A Brick Platinum Card looks like this:

Brick Platinum Card - The Brick

Follow the steps below in order to make online contributions to your Brick Platinum Card from TD EasyWeb:

Login to TD Easy Web and you will land in the View Accounts page.
Find and click the Payments & Transfers link. You will see now the Payments and Transfers page.
Find and click the Add a New Payee button. In the new page, type in HSBC RETAIL SERVICES in the Enter Payee Name text box and click the Search button.
In the new page, write down your Brick Platinum Card number within the Payee Account text box. When doing so, add a leading zero to the 15 digit card number. For example, if your Brick Card number is 0000 1234 5678 999, then you should type 0000 0123 4567 8999. After this click, the Next>> button.
In the next page click the Finish button.
Now you can click the Pay this Payee button in order to make a contribution to the Brick Platinum card right away.

The online payment should be sent 7 days prior to the payment due date to make sure it arrives in time for processing.

This is all for this tutorial. You could also accomplish the same from within the RBC online banking. For details take a look at: Make payments to your Brick Platinum Card from the RBC Online Banking.

If you think this info is useful, then share it with your fiends in Google Plus (G+). For that just click the Google Plus (G+) button close to the title of this post.

Check your Brick Platinum Card balance online

2012-09-05T21:46:00.000-04:00

If you want to check your Brick Platinum Card balance over the Internet, the first thing you need to do is to register with the HSBC Online Customer Care. For that just click here: Enrollment form.

You will be redirected to a registration form in which you will have to type in some information like:

Account Number: The Brick Card number preceded with a zero to the left. For instance, if your Brick Card number is 0000 1234 5678 999, then you should type 0000 0123 4567 8999.
Date of Birth: The Brick Platinum cardholder’s date of birth.
Postal Code: The Brick Platinum cardholder’s postal code
Loing ID and Password: A login and password for accessing the Online Customer Care.
Two security questions: Just in case you forget your credentials in the future (login ID and password)
Email Address: The Brick Platinum cardholder’s email address.
Statement Delivery Preference: Whether you prefer to receive paper statements over regular mail or electronic statements over email. I particularly prefer the electronic statements.
Email Alerts: Check this out if you want to receive email alerts when a payment has been received, when your payment is past due and when a new statement becomes available.

Finally, just click the Submit button at the end of the form. With that you'll have completed the registration process. Shortly after, you will receive an email from HSBC Retail Services welcoming you to the Online Customer Care.

If you want to check your Brick Platinum Card balance just login with your Login ID and Password in the Online Customer Care web portal.

Important: you cannot make online payments from within the Online Customer Care portal. You can only review your statements and balance. If you want to make online contributions to your Brick Platinum Card refer to the following articles:

Make payments to your Brick Platinum Card from the RBC Online Banking

2012-08-27T23:53:00.001-04:00

If you financed some new furniture at The Brick by getting a Brick Platinum Card, then you can arrange your payments thought the RBC online banking. I prefer to do the contributions from the comfort of my home as opposed to physically paying at the store.

Your Brick Platinum Card should look like this:

Brick Platinum Card - The Brick

This is a comprehensive step by step guideline that will allow you to contribute to your Brick Platinum Card balance from the RBC Online Baking:

Sign-in to RBC online baking. Once you sign-in, you’ll see the Accounts Summary page.
Find and click the Pay Bills & Transfer Funds link. You will be redirected to the Pay Bills & Transfer Funds page.
Find and click the Add Payee link. You will be redirected to the Add Payee page.
In the Payee name text box type HSBC RETAIL SERVICES and click the Search button. You will be redirected to a page containing a list of possible payee matches. Select the radio button labeled HSBC RETAIL SERVICES and click the Continue button. You will be redirected to the Payee Information page.
Type in your Brick Platinum Card number in the edit box. When doing so, add a leading zero to the 15 digit card number. For example, if your Brick Card number is 0000 1234 5678 999, then you should type 0000 0123 4567 8999. Once you do this, click the Continue button. You will be redirected to the Add Payee Confirmation page.
Click the Confirm button. You will be redirected to the Add Payee Completed page. At this point you have successfully added your Brick Platinum Card to your list of payees.
To make a payment go to the Accounts Summary page and use the Quick Payments & Transfers dialog. It’s as easy as specifying the source from which you want to take your funds (checking account, saving account, etc.), selecting Brick Platinum HSBC as the receiver of the payment and entering the amount of money that you would like to transfer.

The online transfer should be done 7 days in advance to the payment due date to guarantee it comes in time for processing.

If you bank with TD Canada Trust you might want to check this out: Make payments to your Brick Platinum Card from TD EasyWeb.

That’s all folks :-) If you find this tutorial helpful, would you mind sharing it by clicking the Google Plus (G+) button at the beginning of this post? Thanks!

Test Driven Development in Delphi: The Basics

2012-03-08T11:12:00.020-05:00

I intend to write a Test Driven Development (TDD) series, targeted for Delphi developers. I will use DUnit, the unit testing framework for Delphi.

Note folks that the purpose of this is NOT to discuss the Pros and Cons of TDD, Unit Testing or whatsoever. The purpose is just to give a few examples. I would love if you help me when the complexity starts climbing.

If needed, for a quick understanding of what TDD or Unit Testing is, refer to the links above, or check out the book at the end of the article.

In TDD you don’t write the application code first, instead you write the test cases first. The TDD cycle is as follows:

At the beginning you just write one test, and later on, more tests can be added.
Make sure the initial test fails; this will validate the test harness.
Write some code to pass the test. Important: don’t over-code. Just add the code needed to pass the test and period. The code does not have to be elegant at this point.
Run the test: if it fails, then you have to go back to step 3 and fix your code in order to pass the test. When you succeed, then move on to step 5.
Improve and optimize your code: make it elegant, more efficient, avoid duplications, etc, etc. This is called code refactoring.
When refactoring your code, maybe, by accident, you break the functionality. How can you be sure that everything is working as it should? Just re-run your test and it will tell you if the previous refactoring introduced a failure or not.
Go to step 1 and add a new test if needed.

The example: let’s consider the chess game. The goal will be to implement the code to verify whether a piece is placed in a valid position within the board. We are only going to implement one test: SetPositionTest.

I will number the columns (X coordinate) from 1 to 8 starting at the bottom left-hand corner. In the same way, I will number the rows (Y coordinate) from 1 to 8 starting at the bottom left-hand corner.

8
7
6
5
4
3
2
1 2 3 4 5 6 7 8

For a step by step tutorial of how to use, configure and setup DUnit you can read the English or Chinese versions of the tutorial.

Initially, the testing code should look like this:



unit ChessPiecesTests;



interface



uses

   TestFrameWork;



type

  TPieceTest = class(TTestCase)

  published

    procedure SetPositionTest;

  end;



implementation



uses

  ChessPieces;



{ TPieceTest }



procedure TPieceTest.SetPositionTest;

begin

end;



initialization

  TestFramework.RegisterTest(TPieceTest.Suite);

end.

If you run that test, it will succeed since no checks are being performed within the SetPositionTest procedure.

Each test is composed by one or more checks. I suggest adding the checks little by little. Every time you add a check, you should add business code to pass the corresponding test.

Now, let’s make the test fail on purpose. For that, let’s add one check to the SetPositionTest procedure.



procedure TPieceTest.SetPositionTest;

begin

  Check(True = False,  '');

end;

True is never False. So, this test will fail. If it doesn’t fail, then something is wrong with you test harness. Fix it. You can remove this initial check once you run the test and it fails.

Now, let’s add a real check to our test. Something like this:



procedure TPieceTest.SetPositionTest;

var

  Piece: TPiece;

begin

  Piece:= TPiece.Create;

  try

    //Test trivial (normal) workflow

    Check(Piece.SetPosition(4, 4) = True,  '');

  finally

    Piece.Free;

  end;

end;

If you run this test, you will get a compilation error! Yes, that’s right. You don’t have business code yet. You just have the test. This is what TDD is all about: test first, business code later. Get the point?

To avoid the compilation error, we will code a separate unit (ChessPieces) and we will add it to the uses clause of our ChessPiecesTests unit.



unit ChessPieces;



interface



type

  TPiece = class

  private

  public

    function SetPosition(aX, aY: Integer): Boolean;

  end;



implementation



{ TPiece }



function TPiece.SetPosition(aX, aY: Integer): Boolean;

begin

end;



end.

Run the test again and now the compilation error is gone. Nonetheless, the test fails, because the Piece.SetPosition(4, 4) evaluates to False.

Let’s add the minimum business code possible to pass this test:



function TPiece.SetPosition(aX, aY: Integer): Boolean;

begin

  Result:= True;

end;

This passes the test. What? Yes, this passes the test, right?

OK, what now? Well, we keep adding new checks to the test and every time this happens, we need to add new business code in order to pass it. It is very important to add checks to test the boundaries of whatever we are trying to code. I think you are getting the point, so I will just add a bunch of checks at once:



procedure TPieceTest.SetPositionTest;

var

  Piece: TPiece;

begin

  Piece:= TPiece.Create;

  try

    //Test trivial (normal) workflow

    Check(Piece.SetPosition(4, 4) = True,  '');



    //Tests boundaries

    Check(Piece.SetPosition(1, 1) = True,  '');

    Check(Piece.SetPosition(1, 8) = True,  '');

    Check(Piece.SetPosition(8, 1) = True,  '');

    Check(Piece.SetPosition(8, 8) = True,  '');



    //Test beyond the boundaries

    Check(Piece.SetPosition(3,    15) = False, '');

    Check(Piece.SetPosition(3,   -15) = False, '');

    Check(Piece.SetPosition(15,    3) = False, '');

    Check(Piece.SetPosition(15,   15) = False, '');

    Check(Piece.SetPosition(15,  -15) = False, '');

    Check(Piece.SetPosition(-15,   3) = False, '');

    Check(Piece.SetPosition(-15,  15) = False, '');

    Check(Piece.SetPosition(-15, -15) = False, '');

  finally

    Piece.Free;

end;

The test above is even checking for the attempts of positioning a piece outside the chess board.

To pass that test let’s write some business code:



function TPiece.SetPosition(aX, aY: Integer): Boolean;

begin

  Result:= True;

  if (aY < 1) or (aY > 8) then Result:= False

  else if (aX < 1) or (aX > 8) then Result:= False;

end;

Run the test and see how it passes.

The code above could be refactored or even rewritten. The tests will remain the same, allowing us to catch any bugs introduced with the code change.

For instance, we could write the procedure above as follows:



function TPiece.SetPosition(aX, aY: Integer): Boolean;

begin

  Result:= (aX > 0) and

           (aX < 9) and

           (aY > 0) and

           (aY < 9);

end;

Run the test, and it will tell you if this refactoring (or reimplementation) works ok.

It’s important to note that a good test should cover all possible scenarios and workflows. Pay special attention to the boundaries. At this point, a good understanding of the requisites is indispensable.

Finally, more and more tests will be needed in a real world application. Each test will have its own checks. Each test will cover one piece of the functionality: this is what unit testing is intended for.

For further reading I recommend you Test Driven Development: By Example by Kent Beck. Check it out just below:

Deep copying (cloning) objects in Delphi

2012-02-03T14:26:00.014-05:00

When I first took a look at the prototype design pattern in GoF(years ago), I realized that there was a big obstacle (challenge) to implement it in Delphi: How to write a routine to really clone (not just recreate) an object? In other words, how to perform a deep-copy of a living object in Delphi.

There are approaches out there mimicking the deep copy by simply calling the constructor and reassigning the state of the object by hand (I don’t like it). There are others exposing that a deep copy could be accomplished for the descendants of TPersistent by calling the Assign method (I don’t like it either).

With the new RTTI extensions it seemed to me (and to others) that a deep copy could be accomplished using reflection.

I was reluctant to write the routine myself since the work is not trivial. It could get really nasty because there might be composition, aggregation and God knows what within an arbitrary object.

So I waited….

Just a few days ago, I realized that I could use the JSON marshalling and unmarshalling features introduced in Delphi (2010?) to write the deep copy method. So I came with this:



.....

uses

  DBXJSON, DBXJSONReflect;

.....

function DeepCopy(aValue: TObject): TObject;

var

  MarshalObj: TJSONMarshal;

  UnMarshalObj: TJSONUnMarshal;

  JSONValue: TJSONValue;

begin

  Result:= nil;

  MarshalObj := TJSONMarshal.Create;

  UnMarshalObj := TJSONUnMarshal.Create;

  try

    JSONValue := MarshalObj.Marshal(aValue);

    try

      if Assigned(JSONValue) then

        Result:= UnMarshalObj.Unmarshal(JSONValue);

    finally

      JSONValue.Free;

    end;

  finally

    MarshalObj.Free;

    UnMarshalObj.Free;

  end;

end;

You can now use it like this:



.....

var

  MyObject1,

  MyObject2: TMyObject;

begin

  //Regular object construction

  MyObject1:= TMyObject.Create;



  //Deep copying an object

  MyObject2:= TMyObject(DeepCopy(MyObject1));



  try

    //Do something here



  finally

    MyObject1.Free;

    MyObject2.Free;

  end;

end;

I tested it with some complex cases and it seems to be working quite well. Anyhow, if you find any problems or limitations, please, let me know.

Now that you get the idea we can do more crazy things like patching TObject (or any other class hierarchy) by using helpers. Look at this:



.....

interface



uses

   DBXJSON, DBXJSONReflect;



type

  TObjectHelper = class helper for TObject

    function Clone: TObject;

  end;



implementation



function TObjectHelper.Clone: TObject;

var

  MarshalObj: TJSONMarshal;

  UnMarshalObj: TJSONUnMarshal;

  JSONValue: TJSONValue;

begin

  Result:= nil;

  MarshalObj := TJSONMarshal.Create;

  UnMarshalObj := TJSONUnMarshal.Create;

  try

    JSONValue := MarshalObj.Marshal(Self);

    try

      if Assigned(JSONValue) then

        Result:= UnMarshalObj.Unmarshal(JSONValue);

    finally

      JSONValue.Free;

    end;

  finally

    MarshalObj.Free;

    UnMarshalObj.Free;

  end;

end;

All of a sudden, TObject has a Clone method! Call it like this:



.....

var

  MyObject1,

  MyObject2: TMyObject;

begin

  //Regular object construction

  MyObject1:= TMyObject.Create;



  //Cloning an object

  MyObject2:= TMyObject(MyObject1.Clone);



  try

    //Do something here



  finally

    MyObject1.Free;

    MyObject2.Free;

  end;

end;

If you think that helpers are an aberration, you can still create a TCloneable class with a Clone method and inherit from it, right? You can even use the decorator pattern to attach a Clone method to an object. You can do more…Share it with me, please. Thanks!

String comparison in Delphi

2012-01-26T15:01:00.016-05:00

Have you ever wondered how utilities like Beyond Compare or DIFF are comparing files? They do it (I guess) by solving the longest common subsequence (LCS) problem.

After reading the Wikipedia article linked above, I obtained an overall view of the problem and I looked at the possible resolutions. So, I decided to implement a Delphi class to do the string comparison trick, which is the base for the text file comparison.

Let me put it as follows: given two strings to be compared, I want to highlight in blue the characters added to the first string and in red the characters removed from it. The common (unchanged) characters will keep the default color.

For example:

String 1 = Delphi allows both structural and object oriented programming.

String 2 = Does Delphi allow object oriented programming?

Highlighted differences:

Does Delphi allows both structural and object oriented programming.?

The Delphi class looks like this:



type

  TDiff = record

    Character: Char;

    CharStatus: Char;  //Possible values: [+, -, =]

  end;



  TStringComparer = class

  ……………

  public

    class function Compare(aString1, aString2: string): TList<TDiff>;

  end;

When you call TStringComparer.Compare, a generic list of TDiff records is created. A TDiff record contains a character and whether this character was added (CharStatus = ‘+’), removed (CharStatus = ‘-’) or unchanged (CharStatus = ‘=’) in both strings under comparison.

Let’s drop two edits (Edit1, Edit2), a rich edit (RichEdit1) and a button (Button1) on a Delphi form. To highlight the differences put the following code in the OnClick event of the button:



procedure TForm1.Button1Click(Sender: TObject);

var

  Differences: TList<TDiff>;

  Diff: TDiff;

begin

  //Yes, I know...this method could be refactored ;-)

  Differences:= TStringComparer.Compare(Edit1.Text, Edit2.Text);

  try

    RichEdit1.Clear;

    RichEdit1.SelStart:= RichEdit1.GetTextLen;

    for Diff in Differences do

      if Diff.CharStatus = '+' then

      begin

        RichEdit1.SelAttributes.Color:= clBlue;

        RichEdit1.SelText := Diff.Character;

      end

      else if Diff.CharStatus = '-' then

      begin

        RichEdit1.SelAttributes.Color:= clRed;

        RichEdit1.SelText:= Diff.Character;

      end

      else

      begin

        RichEdit1.SelAttributes.Color:= clDefault;

        RichEdit1.SelText:= Diff.Character;

      end;

  finally

    Differences.Free;

  end;

end;

It looks like in the image below:

For the full implementation read further down. Note that various optimizations could be added to the code below, but I didn’t implement them. Anyway, I hope this helps. Feedback is welcome! Feel free to find and correct bugs ;-)



unit StringComparison;



interface



uses

  Math, Generics.Collections;



type

  TDiff = record

    Character: Char;

    CharStatus: Char;  //Possible values: [+, -, =]

  end;



  TStringComparer = class

  strict private

    type TIntArray = array of array of Integer;

    class function LCSMatrix(X, Y: string): TIntArray;

    class procedure ComputeDifferences(aLCSMatrix: TIntArray;

                                       X, Y: string;

                                       i, j: Integer;

                                       aDifferences: TList<TDiff>);

  public

    class function Compare(aString1, aString2: string): TList<TDiff>;

  end;



implementation



{ TStringComparer }



class function TStringComparer.LCSMatrix(X, Y: string): TIntArray;

var

  m, n,

  i, j: Integer;

begin

  m:= Length(X);

  n:= Length(Y);



  //We need one extra column and one extra row to be filled with zeroes

  SetLength(Result, m + 1, n + 1);



  //First column filled with zeros

  for i := 0 to m do

    Result[i, 0] := 0;



  //First row filled with zeros

  for j:= 0 to n do

    Result[0, j]:= 0;



  //Storing the lengths of the longest common subsequences

  //between prefixes of X and Y

  for i:= 1 to m do

    for j:= 1 to n do

      if X[i] = Y[j] then

        Result[i, j] := Result[i-1, j-1] + 1

      else

        Result[i, j]:= Max(Result[i, j-1], Result[i-1, j]);

end;



class procedure TStringComparer.ComputeDifferences(aLCSMatrix: TIntArray;

                                                   X, Y: string;

                                                   i, j: Integer;

                                                   aDifferences: TList<TDiff>);

var

  CharDiff: TDiff;

begin

  if (i > 0) and (j > 0) and (X[i] = Y[j]) then

  begin

    ComputeDifferences(aLCSMatrix, X, Y, i-1, j-1, aDifferences);

    CharDiff.Character:= X[i];

    CharDiff.CharStatus:= '=';   //The character did not change

    aDifferences.Add(CharDiff);

  end

  else

    if (j > 0) and ((i = 0) or (aLCSMatrix[i,j-1] >= aLCSMatrix[i-1,j])) then

    begin

      ComputeDifferences(aLCSMatrix, X, Y, i, j-1, aDifferences);

      CharDiff.Character:= Y[j];

      CharDiff.CharStatus:= '+'; //The character was added

      aDifferences.Add(CharDiff);

    end

    else if (i > 0) and ((j = 0) or (aLCSMatrix[i,j-1] < aLCSMatrix[i-1,j])) then

    begin

      ComputeDifferences(aLCSMatrix, X, Y, i-1, j, aDifferences);

      CharDiff.Character:= X[i];

      CharDiff.CharStatus:= '-'; //The character was removed

      aDifferences.Add(CharDiff);

    end;

end;



//This is a factory method

class function TStringComparer.Compare(aString1, aString2: string): TList<TDiff>;

var

  Matrix: TIntArray;

begin

  Result:= TList<TDiff>.Create;

  Matrix:= LCSMatrix(aString1, aString2);

  ComputeDifferences(Matrix,

                     aString1, aString2,

                     Length(aString1), Length(aString2),

                     Result);

end;



end.

Testing the World Away: Recovery mission

2012-01-17T13:33:00.008-05:00

I was recently reviewing the DUnit website and I noticed there is a broken link to an article titled “Testing The World Away”. It was written by Will Watts for QBS Software. November, 2000.

I said “OK, maybe the article was relocated somewhere else in the QBS Software website”; so I tried a custom Google search "Testing the World Away" site:qbssoftware.com. As you can see the article was either banned from Google or removed completely from the QBS Software website.

Once again I said “OK, maybe there’s a copy of the article somewhere else on the Internet” and I tried a second custom Google search "Testing the World Away". At this point I convinced myself that the article was gone for good.

I am a curious guy, so I tried one final thing: I looked up the broken link[1] in the Internet Archive website and wallah!, they came with an archived version of the article.

I have shared below a copy of the article so that we can take a look. As I said, this article is not mine, and if the author(owner) at some point request me to deleted it from my blog, I will do so.

[1] http://www.qbss.com/html/news/news_body.asp?content=ARTICLE&link=368&zone=

Testing the World Away (01 November 2000)

Testing the World Away

The software methodology of the hour is Kent Beck’s ‘Extreme Programming’. Mr Beck is a Smalltalk programmer by trade and, I think, a bit of a lad by inclination (evidence: the bibliography of his book Extreme Programming Explained, as well as citing standards such as The Mythical Man-Month and Design Patterns, also recommends Cynthia Heimel’s Sex Tips for Girls. Right on!). I find some of his ideas unconvincing. Pair Programming for example, where one programmer sits at the keyboard and works while the other does something else - possibly flower-arranging, my concentration lapsed at this point in the text as I tried to imagine any manager I’ve met who would permit this exciting way of increasing his costs - seems too beautiful and delicate for our mortal coil. On the other hand his approach to testing, and the free libraries based on his design that are around to back it up, comes much nearer to hitting, as I suppose Ms Heimel might put it, my programming G-spot.

Mr Beck’s idea is that as you write each bit of code, you should also write a little test to go with it. As the project develops, the library of tests builds up in parallel. After each alteration or addition, you rerun the test suite to discover if you have broken anything. One of the rules - and I think it is an important one - is that the test suite must be able to run all the way through, pass or fail, without operator intervention. So although it is a chore to write the tests, the effort put in is ‘banked’, and it costs very little to rerun them - with the consequence that they do get rerun.

Mr Beck has had brushes with those GUI automated tools that record keystrokes and mouse-clicks into some sort of script and then let you play your actions back at the application to be tested and verify its responses. These look like they are going to do the job from the description on the packet but in practice, as Mr Beck correctly observes, they are not very robust. Remove one edit box, or merely nudge it three pixels to the right, or change the screen resolution - suddenly the whole thing falls flat on its face. Testing code, he decided, should be written at the same level and in the same language as the stuff to be tested.

Tests also need structure. One needs to see results presented in a consistent way, to be able to select specific tests to run and so on. To this end, Mr Beck wrote a library of Smalltalk classes - a framework - called ‘SmalltalkUnit’ or ‘SUnit’. Later on he collaborated with no less than Erich Gamma to produce a Java version called ‘JUnit’. The idea ‘took on’, and now there are versions for an impressive range of languages including C++, Eiffel, Objective-C, Perl, Python, Visual Basic and even Visual Objects. You'll find them all listed at http://www.xprogramming.com/software.htm. If you are familiar with my language prejudices, you will be unsurprised to learn that I am going to discuss a Delphi language version called DUnit. Originally ported from the Java version by Juancarlo Añez, this library is now maintained on an Open Source basis by the DUnit group at SourceForge:

https://sourceforge.net/projects/dunit/. This library makes heavy use of function overloading, so you’ll need Delphi 4 or later to play with it.

Who DUnit?
Figure 1 shows a suite of DUnit tests that have been run using the library’s GUI interface. The top pane lists all the tests available. These are organised in a hierarchy: a suites of tests may contain either individual test cases or other suites - a Composite pattern. In the part of the hierarchy visible, I have set up a suite called ‘SFW COM Library tests’ that, in turn, contains suites subdivided by the class being tested. The TTestDoubleChannel suite operates on a class called TDoubleChannel, and below TTestDoubleChannel are tests on individual methods. There are checkboxes to switch individual tests and parts of the hierarchy on and off; these interact with some useful buttons at the bottom of the dialog to allow speedy selection of all or part of the suite.

Each test is colour-coded by the result of the last run. Green, obviously, indicates success; magenta a ‘failure’, that is that an unexpected result was obtained; red, an ‘error’, that the test threw an exception. The lower pane lists all the failures and errors together with descriptive messages. In between the two panes are progress bars indicating progress through the test suite and success rate.

Figure 2 shows DUnit’s text mode version after running the same test suite as Figure 1, and I hope that you can see it has produced the same results. Although lacking the eye candy and versatility of the GUI test runner, this console version requires no interaction and sets its exit code non-zero on failure. This makes it ideal for placing in a make file, or incorporating into an automated testing procedure. By the way, to make my test suite code run as a console application, I substituted one .DPR file for another - about 10 seconds’ work.

How it works

The key class in DUnit’s framework is TTestCase. All the actual testing code is placed in classes that you derive from it. It’s easiest to see how this works with a snippet of code. Figure 3 shows a trivial example of a program that tests 1 + 1 = 2.

First look at the Project1TestCases.pas unit. TTestCaseFirst is derived from TTestCase, adding one published method testFirst. Three features of this method are important: that it is a parameterless procedure, that it has public scope, and that its name begins ‘test…’. These features enable DUnit to discover and run the method without the need to call it explicitly in hand-generated code. It is sufficient to declare a method of a TTestCase-derived class that follows these rules to get it run.

The implementation of testFirst is a single line: I ‘assert’ that 1 + 1 = 2. (Old Delphi hands and practitioners of design-by-contract may be raising their eyebrows at this strange use of Assert. Please bear with me, explanations and excuses will follow in due course.)

At the bottom of Project1TestCases.pas, in an initialization section, is the call registerTest('', TTestCaseFirst); which registers TTestCaseFirst with the framework. The first parameter is the ‘path’, it controls where a test case appears in the hierarchy. By supplying an empty string I am placing it below the root node.

The project file Project1Test.dpr references DUnit library units TestFrameWork and GUITestRunner as well as Project1TestCases.pas. A single line replaces the standard Delphi GUI project code: GUITestRunner.runTest(TestFramework.registeredTests);

This creates and displays the GUI interface shown in Figure 1. And that’s it. To add further arithmetic tests, just write extra test… methods, for example

procedure TTestCaseFirst.testSecond;
begin
Assert(2 + 2 = 5, 'Oops!');
end;

This mistake will be flagged as a magenta-coloured failure when it is run.

In reality one uses DUnit on classes rather than trivial arithmetic. Instances of classes can be placed as member data in the TTestCase-derived class, and two virtual methods, SetUp and TearDown, can be overridden to create and destroy them around each test method. Figure 4 sketches how this is done. Note that SetUp is called before, and TearDown after, each test method. This isolation of the test methods from each other is deliberate - you shouldn’t build a sequence of tests where one method is dependant on those called before.
I mentioned DUnit’s ability to build up suites from multiple test cases. This is accomplished using the TTestSuite class:
Suite := TTestSuite.create('A suite');
Suite.addTests(TTestCaseFirst);
Suite.addTests(TTestCaseMyClass);
The populated suite can then be passed to registerTest as before.

All About Assert

It’s time to own up to a problem with DUnit. The library’s use of the Assert function to check the test conditions is rather perverse. Assert already has a well-understood role in Delphi code, and this isn’t it. How did it get there? Well, you will recall that DUnit is a port of a Java library called JUnit and the Java language, I am informed, doesn’t have an Assert in the C++/Delphi sense. Unfortunately the ‘Assert’ name was carried across with the rest of JUnit. An easy mistake to make: it has also happened to the people doing a C++ version of JUnit.

However, there is a move afoot among the DUnit developers to change the function's name, probably to Check, and also to add a family of useful overloaded methods with names like CheckEqual, CheckNotEqual and so on. With luck this will have gone through by the time you read this.

DUnit is very much work-in-progress, and there are a number of interesting additions and enhancements coming into view. Two add-ons have just been released - one standalone, one integrated with the IDE enhancer CodeRush - which will generate skeleton test case code from the declaration of a class that is to be tested. As well as extra facilities for test repetition and set-up that I have not covered here, there are also plans to add special support for databases, multi-threading and GUI testing.

No technique can stop testing from being a fag. But I have found that the accumulation of a permanent test suite, and the improved confidence in my code developed in this way make DUnit’s use worthwhile. Go on: pull it down and have a go!

Will Watts is a programmer and occasional journo who lives in Chiswick. To his pleasure, his Snobol column in Developers Review has not, as far as he knows, been nominated for the Worst IT Journalism 2000 Award.

Books:
Extreme Programming Explained by Kent Beck, pub Addison-Wesley, ISBN 0-201-61641-6. Mr Beck’s philosophy of software development.
Refactoring - Improving the Design of Existing Code by Martin Fowler et al, pub Addison-Wesley, ISBN 0-201-48567-2. Includes good description of JUnit.

Multiple Entries to the US with the same I-94 Form: Just for Canadian Residents

2012-01-11T16:34:00.040-05:00

I am a Permanent Resident of Canada (Landed Immigrant) and I got a B-2 Visitor Visa which I used in order to travel to the United States of America for 15 days.

I crossed the border at the Rainbow Bridge at Niagara Falls. In the American side of the bridge there is a US Point of Entry, in which I was requested for my papers. I presented my Cuban Passport with a one time B-2 Visitor Visa to the American Officer controlling the crossing. The officer kept my passport and redirected me to one office located just a few meters further.

I waited for 40 minutes and I was called for an interview with another officer. He asked for the purpose of the trip, the intended duration of the stay, my destinations within the States, the means of returning back (flight and bus tickets) [1], my relation to the people I was visiting in the US, and things like that.

The officer issued an I-94 Form, that he stapled onto my passport. I paid a $6.00 USD fee for the I-94 Form and my passport was returned to me. [Make sure you have exactly $6.00 USD (cash) if you want to get this done quickly. You can pay with credit card as well, but it takes more time]

The I-94 Form was issued for 6 moths, meaning that I was permitted to stay in the US until the expiry date, 6 months later.

In my way back to Canada I crossed the Rainbow Bridge again (in the opposite direction). This time I was stopped by a Canadian Custom Officer. She asked for my papers: I gave her my passport and my Canadian Resident Card [2]. She asked pretty much the same questions that the American Officer did, and she also inquired about any merchandize that I was bringing from the US.

I was expecting her to remove the I-94 from the passport, but she didn’t. Usually, you need to surrender your I-94 when leaving the US, but it seems that Canadian Residents can use the same I-94 Form (if not expired) to re-entry to the US multiple times. It seems that you can do this regardless of the validity of your Visa: the only thing taken into consideration is that the I-94 Form has to be valid.

Looking for a validation for my theory I found this post. I am extracting the main juice below:

You don't have to get a new I-94 every time
you enter the USA. How do I know ?, because
I've being traveling to the USA for the past
4.5 years and using the same I-94 until its
expiry date. In fact the INS officer told me
that I did not have to turn in the I-94 if I
intent to enter the USA prior to the expiry
date.

I also talked to a few friends who confirmed that they used the I-94 Form to re-enter the US from Canada, even after their visa was expired.

I looked furthermore to validate this theory and I found out that:

If taking short trips (30 days or less) to Canada, Mexico, or the Caribbean Islands during the course of your visit to the U.S., hold onto your I-94 or I-94 (W); it should only be turned in when you leave the U.S. to return home. [U.S. Department of State]

After this I was pretty confident of my theory and I went to the US a second time. This time I crossed the border at the Peace Bridge. I was not expecting any problems: my visa was expired, but my I-94 was not. You know what? I did have a problem…

The American officer told me that they allow most people visiting the US to re-enter by just using the I-94 (if not expired). The problem in my case is that I am a Cuban national. Cubans (among other nationalities) are taken especial care by the US government. That meant that I was not able to use my I-94 Form to re-enter the US.

I was very disappointed, but the American officer wanted to support my case. She noticed that I made an honest mistake. So, she took my finger prints, made me fill some forms and with that, she supported my case with her superiors. Not even her immediate superior was able to allow me enter the US. So, the whole process took like 3 hours and of course, I lost my bus and the plain.

After all this they gave me a waiver, which is a one time permit to enter the US without a visa. I was glad at this point, because those Americans officers helped me while they were enforcing the law. They removed the original 6 months I-94 from my passport, and they re-issued a new one for just one week (I was going this time for the weekend; so it was good enough for me).

They explicitly told me to surrender this new I-94 Form to the Canadian custom officer in my way back to Canada. I did that of course. Note that you have to advise the Canadian officer to remove the I-94 from your passport. The Canadian officer does not remove it if you don’t ask.

So, the conclusion if that you can use the I-94 Form (if not expired) to re-enter the US from Canada, but this does NOT apply to nationals of Cuba, Iran, Syria, and Sudan. This list could change at any moment.

Disclaimer: This is based on my own experience as a Permanent Resident of Canada. You should not consider this a legal advice or whatsoever.

Just one more thing, after all this hassle I got a new B2-Visitor Visa to enter the US. So, I will be going soon to the States. This time I don’t expect any problems :-)

[1]: I was traveling from Toronto to Buffalo by land; passing though Niagara Falls. Then, I was traveling from Buffalo to Miami by air. I used that route backwards in my way back.
[2]: Don’t forget your Canadian Resident Card. You need it to re-enter Canada.

Delphi Implementation for the OpenSubtitles API

2012-01-09T18:04:00.011-05:00

OpenSubtitles.org allows searching and hosting subtitles in several formats (SRT, SUB, etc.) and pretty much every language. It currently has a vast database of subtitles (expanding every day). OpenSubtitles.org also exposes a XML-RPC based API that can be used in order to build third party applications with subtitle features.

I am writing a Delphi app to search subtitles in the OpenSubtitles.org database... I thought it would be nice to have a Delphi wrapper for the whole API. Below is my three cents contribution. I will probably implement and share more methods in the future, but feel free to contribute as well. Take a look at the full API methods list.

XML-RPC stands for XML Remote Procedure Call. It allows “remote procedure calling using HTTP as the transport and XML as the encoding”. [http://xmlrpc.scripting.com/spec]. XML-RPC is really easy to implement: in the code below I have used formatted strings to conform the XML requests (XML encoding pending) and the Indy TIdHTTP component to send the requests.



unit OpensubtitlesAPI;



interface



uses

  IdHTTP, Classes, SysUtils;



  function LogIn(aUsername, aPassword,

                 aLanguage, aUserAgent: string): string;

  function LogOut(aToken: string): string;

  function SearchSubtitles(aToken, aSublanguageID,

                           aMovieHash: string;

                           aMovieByteSize: Cardinal): string;  overload;

  function SearchSubtitles(aToken, aSublanguageID: string;

                           aImdbID: Cardinal): string; overload;

  function SearchSubtitles(aToken, aSublanguageID,

                           aQuery: string): string;  overload;



implementation



function XML_RPC(aRPCRequest: string): string;

const

  cURL= 'http://api.opensubtitles.org/xml-rpc';

var

  lHTTP: TIdHTTP;

  Source,

  ResponseContent: TStringStream;

begin

  lHTTP := TIdHTTP.Create(nil);

  lHTTP.Request.ContentType := 'text/xml';

  lHTTP.Request.Accept := '*/*';

  lHTTP.Request.Connection := 'Keep-Alive';

  lHTTP.Request.Method := 'POST';

  lHTTP.Request.UserAgent := 'OS Test User Agent';

  Source := TStringStream.Create(aRPCRequest);

  ResponseContent:= TStringStream.Create;

  try

    try

      lHTTP.Post(cURL, Source, ResponseContent);

      Result:= ResponseContent.DataString;

    except

      Result:= '';

    end;

  finally

    lHTTP.Free;

    Source.Free;

    ResponseContent.Free;

  end;

end;



function LogIn(aUsername, aPassword, aLanguage, aUserAgent: string): string;

const

  LOG_IN = '<?xml version="1.0"?>' +

           '<methodCall>' +

           '  <methodName>LogIn</methodName>' +

           '  <params>'   +

           '    <param>'  +

           '      <value><string>%0:s</string></value>' +

           '    </param>' +

           '    <param>'  +

           '      <value><string>%1:s</string></value>' +

           '    </param>' +

           '    <param>'  +

           '      <value><string>%2:s</string></value>' +

           '    </param>' +

           '    <param>'  +

           '      <value><string>%3:s</string></value>' +

           '    </param>' +

           '  </params>'  +

           '</methodCall>';

begin

  //TODO: XML Encoding

  Result:= XML_RPC(Format(LOG_IN, [aUsername, aPassword, aLanguage, aUserAgent]));

end;



function LogOut(aToken: string): string;

const

  LOG_OUT = '<?xml version="1.0"?>' +

           '<methodCall>' +

           '  <methodName>LogOut</methodName>' +

           '  <params>'   +

           '    <param>'  +

           '      <value><string>%0:s</string></value>' +

           '    </param>' +

           '  </params>'  +

           '</methodCall>';

begin

  //TODO: XML Encoding

  Result:= XML_RPC(Format(LOG_OUT, [aToken]));

end;



function SearchSubtitles(aToken, aSublanguageID, aMovieHash: string; aMovieByteSize: Cardinal): string;

const

  SEARCH_SUBTITLES = '<?xml version="1.0"?>' +

                     '<methodCall>' +

                     '  <methodName>SearchSubtitles</methodName>' +

                     '  <params>' +

                     '    <param>' +

                     '      <value><string>%0:s</string></value>' +

                     '    </param>' +

                     '  <param>' +

                     '   <value>' +

                     '    <array>' +

                     '     <data>' +

                     '      <value>' +

                     '       <struct>' +

                     '        <member>' +

                     '         <name>sublanguageid</name>' +

                     '         <value><string>%1:s</string>' +

                     '         </value>' +

                     '        </member>' +

                     '        <member>' +

                     '         <name>moviehash</name>' +

                     '         <value><string>%2:s</string></value>' +

                     '        </member>' +

                     '        <member>' +

                     '         <name>moviebytesize</name>' +

                     '         <value><double>%3:d</double></value>' +

                     '        </member>' +

                     '       </struct>' +

                     '      </value>' +

                     '     </data>' +

                     '    </array>' +

                     '   </value>' +

                     '  </param>' +

                     ' </params>' +

                     '</methodCall>';



begin

  //TODO: XML Encoding

  Result:= XML_RPC(Format(SEARCH_SUBTITLES, [aToken, aSublanguageID, aMovieHash, aMovieByteSize]));

end;



function SearchSubtitles(aToken, aSublanguageID: string;

  aImdbID: Cardinal): string;

const

  SEARCH_SUBTITLES = '<?xml version="1.0"?>' +

                     '<methodCall>' +

                     '  <methodName>SearchSubtitles</methodName>' +

                     '  <params>' +

                     '    <param>' +

                     '      <value><string>%0:s</string></value>' +

                     '    </param>' +

                     '  <param>' +

                     '   <value>' +

                     '    <array>' +

                     '     <data>' +

                     '      <value>' +

                     '       <struct>' +

                     '        <member>' +

                     '         <name>sublanguageid</name>' +

                     '         <value><string>%1:s</string>' +

                     '         </value>' +

                     '        </member>' +

                     '        <member>' +

                     '         <name>imdbid</name>' +

                     '         <value><string>%2:d</string></value>' +

                     '        </member>' +

                     '       </struct>' +

                     '      </value>' +

                     '     </data>' +

                     '    </array>' +

                     '   </value>' +

                     '  </param>' +

                     ' </params>' +

                     '</methodCall>';



begin

  //TODO: XML Encoding

  Result:= XML_RPC(Format(SEARCH_SUBTITLES, [aToken, aSublanguageID, aImdbID]));

end;



function SearchSubtitles(aToken, aSublanguageID,

  aQuery: string): string;

const

  SEARCH_SUBTITLES = '<?xml version="1.0"?>' +

                     '<methodCall>' +

                     '  <methodName>SearchSubtitles</methodName>' +

                     '  <params>' +

                     '    <param>' +

                     '      <value><string>%0:s</string></value>' +

                     '    </param>' +

                     '  <param>' +

                     '   <value>' +

                     '    <array>' +

                     '     <data>' +

                     '      <value>' +

                     '       <struct>' +

                     '        <member>' +

                     '         <name>sublanguageid</name>' +

                     '         <value><string>%1:s</string>' +

                     '         </value>' +

                     '        </member>' +

                     '        <member>' +

                     '         <name>query</name>' +

                     '         <value><string>%2:s</string></value>' +

                     '        </member>' +

                     '       </struct>' +

                     '      </value>' +

                     '     </data>' +

                     '    </array>' +

                     '   </value>' +

                     '  </param>' +

                     ' </params>' +

                     '</methodCall>';



begin

  //TODO: XML Encoding

  Result:= XML_RPC(Format(SEARCH_SUBTITLES, [aToken, aSublanguageID, aQuery]));

end;



end.

Finally, I present you some sample calls:

Logging- in anonymously (empty credentials) and getting the token:

LogIn('', '', 'en', 'OS Test User Agent');

Logging- out (disposing the token):

LogOut('81nt6bgl9vde06l3ptq7v1a7r1');

Search English subtitles for the movie whose ImdbID is 120737

SearchSubtitles(Edit1.Text, 'eng', 120737);

Search English subtitles for The Lord of the Rings

SearchSubtitles(Edit1.Text, 'eng', 'The Lord of the Rings');

Search English subtitles for the movie whose hash is 7d9cd5def91c9432 and size is 735934464.

SearchSubtitles(Edit1.Text, 'eng', '7d9cd5def91c9432', 735934464);

Request the Google PageRank the Delphi way

2011-12-14T13:18:00.019-05:00

In this post I am implementing the Delphi way to request the Google Toolbar’s PageRank (PR). As an example, if I want to look up the PR of my blog (http://www.yanniel.info/), I will have to query the following URL:

http://toolbarqueries.google.com/tbr?client=navclient-auto&features=Rank&ch=64012521073&q=info:http://www.yanniel.info/

So, if you try



Writeln(Curl('http://toolbarqueries.google.com/tbr?client=navclient-auto&features=Rank&ch=64012521073&q=info:http://www.yanniel.info/'));

You will get the following output:

Rank_1:1:0

Oops, at this moment my PageRank is pathetic (PR = 0). Hopefully it will get better someday ;-)

You can find the implementation of the Curl function in my previous post: Fetching a web page with Delphi.

Now that you get the idea, it’s time to generalize our implementation in order to get the PR of any web page.

In the URL above there are two dynamic parameters that we need to understand:

Parameter q: This is the concatenation of “info:” plus the encoded URL for which we want to get the PR. It is mandatory to lead the encoded URL with “http://”. Don’t forget to put a “/” after the top domain, ei, “.info/”, not “.info”.

Parameter ch: Obtaining this parameter is the tricky part. We have to hash the concatenation of “info:” plus our target URL (ei. http://www.yanniel.info/) using the minimal perfect hashing algorithm invented by Bob Jenkins. The outcome will be a number, which corresponds to the value of our ch parameter. We are hashing something like “info:http://www.yanniel.info/”.

I didn’t have the time (or the desire) to understand and implement the minimal perfect hashing algorithm from scratch. So, I ported this C# implementation into Delphi code.

There’s one detail worth mentioning about the implementation. In the original C# code there’s a switch statement that falls all the way through the different cases. I needed to combine a case statement and some goto statements in order to accomplish the same in Delphi. Really, I tried to avoid the goto, I always do, but I couldn’t find a better and cleaner way of implementation. I was telling myself how bad programmer I was, and then, I read one entry in Delphi Feeds talking about the minimal perfect hashing algorithm, and more than that, highlighting the goto issue. Nick Hodges wrote the post: thank you Nick... now I can sleep again.

It seems that I am not the only one considering this goto usage as an exception to the good practice of “don’t use goto statements”. The funny thing is that I read Nick’s post without the intention of finding anything about the minimal perfect hashing algorithm or about the goto stuff. It’s really a big coincidence that we were considering to write about the minimal perfect hashing algorithm (and the goto gotcha) at the same time.

I wrote the strikeout text above initially; but Brian (first comment below) found a clean way to avoid the goto in this situation. I really thank Brian for his contribution, and next time, I won't quit that easily in removing the goto ;-)

I am putting everything together in the Delphi console application below. I bet you can reuse the BobJenkinsHash function in the Generics.Default.pas unit to make the PR implementation more compact. I didn’t know about the BobJenkinsHash function shipped with Delphi before reading Nick’s post; which is why I am keeping my original implementation.

Finally, this is how you request the Google PageRank in Delphi:

program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
System.SysUtils, IdHTTP, IdURI, Classes;

type
TByteArray = array of Byte;

function Curl(aURL: string): string;
const
cUSER_AGENT = 'Mozilla/4.0 (MSIE 6.0; Windows NT 5.1)';
var
IdHTTP: TIdHTTP;
Stream: TStringStream;
begin
Result := '';
IdHTTP := TIdHTTP.Create(nil);
Stream := TStringStream.Create;
try
    IdHTTP.Request.UserAgent := cUSER_AGENT;
    try
      IdHTTP.Get(aURL, Stream);
      Result := Stream.DataString;
    except
      Result := '';
    end;
finally
    Stream.Free;
    IdHTTP.Free;
end;
end;

procedure Hashing(var a, b, c: Integer);
begin
a:= a - b;
a:= a - c;
a:= a xor (c shr 13);
b:= b - c;
b:= b - a;
b:= b xor (a shl 8);
c:= c - a;
c:= c - b;
c:= c xor (b shr 13);
a:= a - b;
a:= a - c;
a:= a xor (c shr 12);
b:= b - c;
b:= b - a;
b:= b xor (a shl 16);
c:= c - a;
c:= c - b;
c:= c xor (b shr 5);
a:= a - b;
a:= a - c;
a:= a xor (c shr 3);
b:= b - c;
b:= b - a;
b:= b xor (a shl 10);
c:= c - a;
c:= c - b;
c:= c xor (b shr 15);
end;

function StrOrd(aValue: string): TByteArray;
var
I: Integer;
begin
SetLength(Result, Length(aValue));
for I:= 1 to Length(aValue) do
Result[I-1]:= Ord(aValue[I]);
end;

function PerfectHash(aURL: string): string;
var
url: TByteArray;
_length,
k, len: Integer;
a, b, c: Integer;

label
One,
Two,
Three,
Four,
Five,
Six,
Seven,
Eight,
Nine,
Ten;

begin
url:= StrOrd(aURL);
_length:= Length(url);
k:= 0;
len:= _length;
a:= $9E3779B9;
b:= $9E3779B9;
c:= $E6359A60;

while (len >= 12) do
begin
a:= a + (url[k + 0] + (url[k + 1] shl 8) +
(url[k + 2] shl 16) + (url[k + 3] shl 24) );

b:= b + (url[k + 4] + (url[k + 5] shl 8) +
(url[k + 6] shl 16) + (url[k + 7] shl 24) );

c:= c+ (url[k + 8] + (url[k + 9] shl 8) +
(url[k + 10] shl 16) + (url[k + 11] shl 24));

    Hashing(a, b, c);
    k:= k + 12;
    len:= len - 12;
end;

c:= c + integer(_length);
case len of
      11: begin
            c:= c + (url[k + 10] shl 24);
            goto Ten;
          end;
      10: begin
            Ten:
            c:= c + (url[k + 9] shl 16);
            goto Nine;
          end;
      9: begin
            Nine:
            c:= c + (url[k + 8] shl 8);
            goto Eight;
          end;
      8: begin
            Eight:
            b:= b + (url[k + 7] shl 24);
            goto Seven;
          end;
      7: begin
            Seven:
            b:= b + (url[k + 6] shl 16);
            goto Six;
          end;
      6: begin
            Six:
            b:= b + (url[k + 5] shl 8);
            goto Five;
          end;
      5: begin
            Five:
            b:= b + (url[k + 4]);
            goto Four;
          end;
      4: begin
            Four:
            a:= a + (url[k + 3] shl 24);
            goto Three;
          end;
      3: begin
            Three:
            a:= a + (url[k + 2] shl 16);
            goto Two;
          end;
      2: begin
            Two:
            a:= a + (url[k + 1] shl 8);
            goto One;
          end;
      1: begin
            One:
            a:= a + (url[k + 0]);
          end;
end;

Hashing(a, b, c);
Result:= Format('6%0:u', [c]);
end;

function GetPageRank(aURL: string): string;
const
cToolbarQueriesURL = 'http://toolbarqueries.google.com/tbr?client=navclient-auto&features=Rank&ch=%0:s&q=%1:s';
var
CH, Q: string;
begin
aURL:= StringReplace(aURL, 'http://', '', []);
if Pos('/', aURL) = 0 then
aURL:= aURL + '/';
aURL:= 'http://' + aURL;

CH:= PerfectHash('info:' + aURL);
Q:= 'info:' + TIdURI.URLEncode(aURL);

Result:= Curl(Format(cToolbarQueriesURL, [CH, Q]));
end;

begin
Writeln(GetPageRank('http://www.yanniel.info/'));
Writeln(GetPageRank('http://www.delphifeeds.com/'));
Writeln(GetPageRank('http://www.google.com/'));
Readln;
end.

Pascal Server Pages – Pascal Script

2011-12-09T11:08:00.013-05:00

Without getting too technical, I would define a Pascal Server Page (PSP) as a dynamic web page containing embedded Pascal Script (PS) code. When a web request is made, the PS code needs to be executed (interpreted) in the server side and outputted into the proper format (HTML, XML, JSON, text, etc). A PSP is commonly stored as a text file in the Web Server and it could be a mixture of PS code plus any other static content.

This is an example of PSP:

<html>
<head>
 <title>This is a Pascal Server Page</title>
</head>
<body>
 <% begin
 Write('Hello World');
 end.
 %>
 I am going to use Pascal Script to write a few numbers...
 <% var
 i: Integer;
 begin
 for i:=1 to 10 do
 Writeln(i);
 end.
 %>
</body>
</html>

The code above is an HTML armature containing some PS code. The PS code has been isolated within the “<%” and “%>” tokens. The PS code is executed in the server and the output (if any) is embedded into the HTML template.

So, if a browser asks for the page above, it will actually get plain HTML code as the one below:

<html>

<head>

<title>This is a Pascal Server Page</title>

</head>

<body>

Hello World

I am going to use Pascal Script to write a few numbers...

1 2 3 4 5 6 7 8 9 10 

</body>

</html>

This is all good. The only problem is that the PS code is not going to be magically executed. We need a server side component to do the PS interpretation.

I have seen a couple of intents to build such server side component in the Internet. Anyhow, I bring you my own proposal: create a Web Broker application with Pascal Scripting capabilities. To provide the Web Broker application with the scripting capabilities, I will use Pascal Script from RemObjects. You need to download and install Pascal Script if you want to try my code.

The workflow goes as follows:

The Web Broker application receives a Web Request.
The Web Broker application finds the corresponding Pascal Server Page and loads its content to a buffer variable.
The content of the buffer variable is parsed in order to find the PS tokens (I will use RegEx to do the parsing).
Each PS block is compiled to Bytecode and then executed in the server. (I will use the Pascal Script library from RemObjects for this purpose).
The output generated from the execution of each PS block replaces its corresponding “<%......%>” block.
The Web Broker app serves the response.

I developed a VCL standalone Web Broker application as a proof of concept (it could be an ISAPI dll as well). See it in action in the following video:

That application is just a prototype. I really believe that we could build a robust server side component to leverage enterprise Pascal Server Pages. I used Web Broker in this example, but we could also build Apache Modules with Free Pascal.

I am posting below the code of the TWebModule1 class, which is the core of the Web Broker app. The full source code and executable can be downloaded here. (the code was compiled with Delphi XE2). Note that the code is somewhat messy; this was taken directly from my sandbox. Ah, I copy-pasted (and adjusted) the Pascal Script routines from this example: Introduction to Pascal Script.

unit WebModuleUnit1;

interface

uses System.SysUtils, System.Classes, Web.HTTPApp,
RegularExpressions;

type
TWebModule1 = class(TWebModule)
    procedure WebModule1DefaultHandlerAction(Sender: TObject;
      Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
private
    { Private declarations }
public
    { Public declarations }
    function LoadStrFromFile(aFilename: string): string;
    function ProducePage(aContent: string): string;
    function ExecPascalScript(const Match: TMatch): string;
    function CompileScript(Script: AnsiString; out Bytecode, Messages: AnsiString): Boolean;
    function RunCompiledScript(Bytecode: AnsiString; out RuntimeErrors: AnsiString): Boolean;
end;

var
WebModuleClass: TComponentClass = TWebModule1;

//ScriptOutput is not thread safe.
//ScriptOutput is a global variable.
//We should avoid global variables.
//TODO: Find a better way to store the script output
ScriptOutput: string;

implementation

uses
uPSCompiler, uPSRuntime;

{$R *.dfm}

procedure Write(P1: Variant);
begin
//This try...except is ugly.
//TODO: Use a conditional checking instead
try
ScriptOutput:= ScriptOutput + String(P1);
except
ScriptOutput:= '';
end;
end;

procedure Writeln(P1: Variant);
begin
Write(P1);
ScriptOutput:= ScriptOutput + '';
end;

function TWebModule1.LoadStrFromFile(aFilename: string): string;
begin
Result:= '';
if not FileExists(aFilename) then Exit;

with TStringStream.Create do
try
    LoadFromFile(aFilename);
    Result:= DataString;
finally
    Free;
end;
end;

function TWebModule1.ProducePage(aContent: string): string;
var
RegEx: TRegEx;
begin
ScriptOutput:= '';
aContent:= StringReplace(aContent, #13#10, '', [rfReplaceAll]);
RegEx.Create('\<\%(.)*?\%\>');
Result:= regex.Replace(aContent, ExecPascalScript);
end;

function TWebModule1.ExecPascalScript(const Match: TMatch): string;
var
Bytecode,
Messages,
RuntimeErrors: AnsiString;
PS: string;
begin
Result:= '';
Bytecode:= '';
ScriptOutput:= '';
PS:= Match.Value;
PS:= StringReplace(PS, '<%', '', []);
PS:= StringReplace(PS, '%>', '', []);
if CompileScript(PS, Bytecode, Messages) then
if RunCompiledScript(Bytecode, RuntimeErrors) then
Result:= ScriptOutput;
end;

function ExtendCompiler(Compiler: TPSPascalCompiler; const Name: AnsiString): Boolean;
begin
Result := True;
try
    Compiler.AddDelphiFunction('procedure Writeln(P1: Variant);');
    Compiler.AddDelphiFunction('procedure Write(P1: Variant);');
except
    Result := False; // will halt compilation
end;
end;

function TWebModule1.CompileScript(Script: AnsiString; out Bytecode, Messages: AnsiString): Boolean;
var
Compiler: TPSPascalCompiler;
i: Integer;
begin
Bytecode:= '';
Messages:= '';

Compiler:= TPSPascalCompiler.Create;
Compiler.OnUses:= ExtendCompiler;
try
    Result:= Compiler.Compile(Script) and Compiler.GetOutput(Bytecode);
    for i:= 0 to Compiler.MsgCount - 1 do
      if Length(Messages) = 0 then
        Messages:= Compiler.Msg[i].MessageToString
      else
        Messages:= Messages + #13#10 + Compiler.Msg[i].MessageToString;
finally
    Compiler.Free;
end;
end;

procedure ExtendRuntime(Runtime: TPSExec; ClassImporter: TPSRuntimeClassImporter);
begin
Runtime.RegisterDelphiMethod(nil, @Writeln, 'Writeln', cdRegister);
Runtime.RegisterDelphiMethod(nil, @Write, 'Write', cdRegister);
end;

function TWebModule1.RunCompiledScript(Bytecode: AnsiString; out RuntimeErrors: AnsiString): Boolean;
var
Runtime: TPSExec;
ClassImporter: TPSRuntimeClassImporter;
begin
Runtime:= TPSExec.Create;
ClassImporter:= TPSRuntimeClassImporter.CreateAndRegister(Runtime, false);
try
    ExtendRuntime(Runtime, ClassImporter);
    Result:= Runtime.LoadData(Bytecode)
          and Runtime.RunScript
          and (Runtime.ExceptionCode = erNoError);
    if not Result then
      RuntimeErrors:= PSErrorToString(Runtime.LastEx, '');
finally
    ClassImporter.Free;
    Runtime.Free;
end;
end;

procedure TWebModule1.WebModule1DefaultHandlerAction(Sender: TObject;
Request: TWebRequest; Response: TWebResponse; var Handled: Boolean);
var
HTMLSource,
HTMLPascalScriptEmbedded: string;
begin
//Set up HTMLSource at your convenience
HTMLSource:= GetCurrentDir + '\testPage.htm';
HTMLPascalScriptEmbedded:= LoadStrFromFile(HTMLSource);
Response.Content:= ProducePage(HTMLPascalScriptEmbedded);
end;

end.

Salary Guide for Delphi developers: Let’s make it

2011-12-02T23:41:00.009-05:00

If you work as an IT professional in North America, you should probably find very useful the 2012 Technology Salary Guide published by Robert Half Technology.

This guide exposes the compensation trends (salary trends) for pretty much every position in Information Technology. It covers the United States of America and Canada, and you could even obtain salary ranges for particular cities.

This guide is useful for both managers and non-managers individuals. In my particular case, I am always curious to know if I am getting paid decently.

The tables below are an excerpt taken from the guide:

2012 Average Starting Salaries – United States

Job Title	2011	2012	% Change
Software Developer	$ 65,750 - $ 104,250	$ 70,000 - $ 111,000	6.5%

2012 Average Starting Salaries – Canada

Job Title	2011	2012	% Change
Software Developer	$ 56,250 - $ 94,000	$ 59,750 - $ 99,750	6.2%

There are further statistics in the guide about Java, .NET, C++, PHP and other programming languages. You can use that info in order to tune the indicators above even more. There are no details about Delphi in this guide.

I think that we (the Delphi community) could gather some statistics about the salary rates for Delphi Developers. I propose running poll surveys to gather such information. Once the polls are closed, we will publish the outcomes and we can draft our conclusions.

The polls are finally closed. Go to the end of this post and take a look at the outcomes. Thanks a lot to all the participants: 45 in the United States and 30 in Canada. It’s funny how the number of voters was a multiple of 5 in both countries :-)

Take a look at the right column of this page: I have published two polls to collect the information about the salary rates in the United States and Canada. I am only putting together the data for these two countries, because I already have some reference data to compare with. (I am referring to the data in the tables above). It would be really nice if someone else could take ownership of similar polls for other countries.

~~Important:~~

~~I will kindly ask to vote, IF and ONLY IF, you are (were) working as a Delphi Developer in the United States or Canada during the current year 2011.~~
~~We could make this better if you enroll your coworkers or any other Delphi developers in your area.~~
~~The poll is by nature anonymous: we are just gathering collective information.~~

Please, in order for this to work we need your vote!

What’s the salary for a Delphi Developer in the United States?

< $ 50,000 5 (11%)
$ 50,000 - $ 60,000 2 (4%)
> $ 60,000 - $ 65,000 1 (2%)
> $ 65,000 - $ 75,000 7 (15%)
> $ 75,000 - $ 85,000 12 (26%)
> $ 85,000 - $ 95,000 4 (8%)
> $ 95,000 - $ 105,000 5 (11%)
> $ 105,000 - $ 115,000 4 (8%)
> $ 115,000 5 (11%)

What’s the salary for a Delphi Developer in Canada?

< $ 50,000 6 (20%)
$ 50,000 - $ 60,000 5 (16%)
> $ 60,000 - $ 65,000 2 (6%)
> $ 65,000 - $ 75,000 3 (10%)
> $ 75,000 - $ 85,000 2 (6%)
> $ 85,000 - $ 95,000 1 (3%)
> $ 95,000 - $ 105,000 5 (16%)
> $ 105,000 - $ 115,000 1 (3%)
> $ 115,000 5 (16%)

Generating Fibonacci numbers in Delphi: Recursive and iterative algorithms

2011-11-30T16:38:00.013-05:00

In this post, I want to implement a function that returns the Nth Fibonacci number. Initially, I will provide a recursive implementation that derives directly from the Fibonacci sequence definition. Afterwards, I will recode the same function using an iterative approach.

Why do I want to do (share) such a thing? Well, firstly for fun :-) and secondly, because I was asked to do something similar in one phone screen interview. Really? Yep, I was asked to code a function to return the factorial of a number and then, I had to read it over the phone. I implemented the recursive algorithm. At this point, I was asked why I decided to use recursion as opposed to iteration. My answer was that I find the recursive implementation easier (and cleaner) to write. The interviewer finally inquired me about the iterative implementation…

This motivated me to resolve similar programming tasks (recursively and iteratively) just as a training exercise.

Well, enough with that blah, blah, blah.

Taken from Wikipedia:

The Fibonacci numbers form a sequence of integers, mathematically defined by

F(0)=0; F(1)=1; F(n) = F(n - 1) + F(n - 2) for n > 1.

This results in the following sequence of numbers:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, ...

This simply means that by definition the first Fibonacci number is 0, the second number is 1 and the rest of the Fibonacci numbers are calculated by adding the two previous numbers in the sequence.

Translating that into Delphi code:

function Fibonacci(aNumber: Integer): Integer;

begin
if aNumber < 0 then
raise Exception.Create('The Fibonacci sequence is not defined for negative integers.');

case aNumber of
0: Result:= 0;
1: Result:= 1;
else
Result:= Fibonacci(aNumber - 1) + Fibonacci(aNumber - 2);
end;
end;

The function above is the recursive implementation, which in my opinion fits naturally. Now, the iterative implementation might not be as cleaner as that:

function Fibonacci(aNumber: Integer): Integer;

var
I,
N_1,
N_2,
N: Integer;
begin
if aNumber < 0 then
 raise Exception.Create('The Fibonacci sequence is not defined for negative integers.');

case aNumber of
 0: Result:= 0;
 1: Result:= 1;
else
 begin
 N_1:= 0;
 N_2:= 1;
 for I:=2 to aNumber do
 begin
 N:= N_1 + N_2;
 N_1:= N_2;
 N_2:= N;
 end;
 Result:= N;
 end;
end;
end;

Finally, if you want to produce the first 21 Fibonacci numbers try this out:

program Project2;

{$APPTYPE CONSOLE}

{$R *.res}

uses
System.SysUtils;

var
I: Integer;

function Fibonacci(aNumber: Integer): Integer;
begin
{Your implementation goes here}
end;

begin
for I:=0 to 20 do
Writeln(Fibonacci(I));
Readln;
end.

Hopefully you are not bored to death :-)

Internationalizing your Delphi application: An ABC example

2011-11-25T18:34:00.008-05:00

If you want to make your Delphi application general enough to address multiple locales, then you need to internationalize it. There are three common aspects that I want to emphasize (no necessarily in that order):

Resourcing
Unit conversions
Dynamic messages

We’ll cover the three of them with a very simple example. Consider the following code snipped intended for the en-US locale (English-United States of America):



procedure TForm1.DefineFever;

begin

  ShowMessage('If the body temperature rises above 99°F the person is considered to have a fever.');

end;

Resourcing is the process of removing hard-coded strings from the code by making them resourcestrings instead.

The code above is not localizable because the ShowMessage procedure is taking a hard-coded string. What do you do? Take a look:



procedure TForm1.DefineFever;

resourcestring

  strFeverDefinition = 'If the body temperature rises above 99°F the person is considered to have a fever.';

begin

  ShowMessage(strFeverDefinition);

end;

We defined strFeverDefinition as a resourcestring and used it as a parameter for the ShowMessage procedure. The functionality remains the same, but the function is now localizable.

Unit conversions: In some countries (like the United States and Belize) the temperature is given in the Fahrenheit scale, but in the rest is given in the Celsius scale. In order to internationalize this we can do the following:



function GetFeverTemperature: string;

var

LangID

: LangID;

begin

  //By default

  Result:= '37.2°C';



  {read current system locale}

LangID

 := GetSystemDefaultLangID;



  //Assuming that only the United States and Belize use the Fahrenheit scale

  if (

LangID = {English - United States} 1033) or
(LangID = {English - Belize} 10249) then

   Result:= '99°F';

end;



procedure TForm1.DefineFever;

begin

  ShowMessage('If the body temperature rises above ' + GetFeverTemperature + ' the person is considered to have a fever');

end;

Wait a minute, we managed the unit conversion by introducing a dynamic message, but we reintroduced the hard-coded strings. That’s not good!

Dynamic messages: We consider the ShowMessage above to be a dynamic message, because the parameter depends on the GetFeverTemperature function, which of course can vary.

To solve the pitfall above we can refactor the DefineFever function as follows:



procedure TForm1.DefineFever;

resourcestring

  strFeverDefinition = 'If the body temperature rises above %0:s the person is considered to have a fever.';

begin

  ShowMessage(Format(strFeverDefinition, [GetFeverTemperature]));

end;

We are just using a format string (resourcestring) that we can format by using the Format routine. This allows resourcing and handling the dynamic message all at once.

The thing about dynamic messages goes beyond. In Spanish, for instance, the dynamic message would have been coded as follows:



ShowMessage('Se considera que la persona tiene fiebre si la temperatura corporal es superior a ' + GetFeverTemperature);

Note that the GetFeverTemperature is at the end of the ShowMesssage parameter, as opposed to the English implementation that has it in the middle. There’s no way you can localize something like this if you don’t internationalize it first.

So the ABC for Delphi localization is Resourcing, Unit Conversions and Dynamic Messages.

Multiton Design Pattern in Delphi

2011-11-21T18:34:00.006-05:00

The multiton is somewhat an extension of the singleton pattern. It is referred as registry of singletons by the GOF. I don’t know for sure who appointed the name multiton: it’s an analogy derived from the term singleton. So, singleton = single + ton; while multiton = multi + ton.

The singleton pattern guarantees that a class has only one instance; while the multiton allows keeping multiple instances by maintaining a map of related keys and unique objects. Note that there can be only one instance per key when implementing the multiton pattern. Also, note that the key does not have to be a string value; it can be an object for example. Nonetheless, in our code sniped we will consider the key to be a string.

I am going to tweak my singleton class implementation so that I can make it a multiton instead:



unit Multiton;



interface



uses

  Generics.Collections;



type

  TMultiton = class

  private

    //Private fields and methods here...



     class var _registry: TDictionary<string, TMultiton>;

  protected



  public

    class function Create(aName: string): TMultiton;

    class destructor Destroy;

    class function Lookup(aName: string): TMultiton;

   

    destructor Destroy; override;



    //Other public methods and properties here...   

  end;



implementation



{ TMultiton }



class function TMultiton.Create(aName: string): TMultiton;

begin

  if not Assigned(_registry) then

    _registry:= TDictionary<string, TMultiton>.Create;



  if not _registry.TryGetValue(aName, Result) then

  begin

    Result:= inherited Create as Self;

    _registry.Add(aName, Result);

  end;

end;



class destructor TMultiton.Destroy;

begin

   if Assigned(_registry) then

   begin

     _registry.Values.ToArray[0].Free;      

   end;

end;



class function TMultiton.Lookup(aName: string): TMultiton;

begin

  if Assigned(_registry) then

    _registry.TryGetValue(aName, Result);

end;



destructor TMultiton.Destroy;

var

  _instance: TMultiton;

  ValuesArray: TArray<TMultiton>;          

begin

  if Assigned(_registry) then

  begin

    ValuesArray:= _registry.Values.ToArray;



    _registry.Clear;

    _registry.Free;

    _registry:= nil;



    for _instance in  ValuesArray do

      if _instance <> Self then

        _instance.Free;

  end;



  inherited;

end;



end.

A few things I want you to note:

Instead of a single instance, we are holding a registry of instances. We do so by introducing the class variable _registry of type TDictionary<string, TMultiton>.
We register (create) the different instances by calling the class function Create. This function gets the key name as a parameter. A new instance is only created if no matches to the key name are found in the dictionary. If a match is found, then the corresponding value is returned from the dictionary data structure.
The Lookup class function allows retrieving a particular instance by giving its key name. Note that the Create function can also be used for this purpose, but it feels more natural to call Lookup for the searches, and Create for the registration (creation) of instances.
We have provided a regular destructor that once invoked releases all the memory: not only the current multiton instance, but the whole registry.
We have also provided a class destructor in case that we forget to manually release the memory.

This code was compiled with Delphi XE2, but it should also work for all versions above Delphi 2009. Comments, corrections and suggestions are most welcome.

Consider reading these books about design patterns if you haven’t yet:

Dependency Injection in Delphi: a simple example

2011-11-03T11:18:00.015-04:00

I want to give a fairly simple Delphi example that will expose the dependency injection pattern. No framework, no third-party library will be needed here: just plain Delphi code.

I won’t dig into the different forms of dependency injection. I will explain the idea of the pattern as simple as possible.

Instead of giving you bunch of definitions, I will present you with some code. The need to inject a dependency will come naturally. You’ll see:

type

IDependency = interface

['{618030A2-DB17-4532-81D0-D5AA6F73DC66}']

procedure GetType;

end;

TDependencyA = class(TInterfacedObject, IDependency)

public

procedure GetType;

end;

TDependencyB = class(TInterfacedObject, IDependency)

public

procedure GetType;

end;

TConsumer = class

private

FDependency: IDependency;

public

constructor Create(aDependencyClassName: string);

procedure GetDependencyType;

end;

implementation

{ TDependencyA }

procedure TDependencyA.GetType;

begin

WriteLn('Instance of type TDependencyA');

end;

{ TDependencyB }

procedure TDependencyB.GetType;

begin

WriteLn('Instance of type TDependencyB');

end;

{ TConsumer }

constructor TConsumer.Create(aDependencyClassName: string);

begin

if aDependencyClassName = 'TDependencyA' then

FDependency:= TDependencyA.Create

else if aDependencyClassName = 'TDependencyB' then

FDependency:= TDependencyB.Create;

end;

procedure TConsumer.GetDependencyType;

begin

if FDependency <> nil then

FDependency.GetType;

end;

It is a good and recommended practice in OOP to decrease coupling as much as possible. This means that each component (class) should avoid knowing implementation details of the other components (classes).

In our example, the TConsumer class has a dependency of type IDependency. So far so good, since we are abstracting any implementation specifics by using an interface (contract). The problem becomes obvious when you take a look at the constructor of TConsumer.

TConsumer.Create is instantiating the concrete classes TDependencyA or TDependencyB depending on the string parameter aDependencyClassName. As you can see, the design is not well decupled here, because the consumer class (TConsumer) is hard-coding implementation details about its dependency.

The question is: can we decuple this design even more? Yes, the dependency injection pattern will do it for us.

It’s now time to refactor our code a little bit. We’ll start by changing the signature of the constructor of the TConsumer class:

constructor TConsumer.Create(aDependency: IDependency);

begin

FDependency:= aDependency;

end;

Instead of choosing the concrete dependency to instantiate within the constructor, we are now injecting the dependency trough the aDependency parameter. Now the class TConsumer is completely independent of the dependency concrete class.

Ok, ok, but we still need to create the concrete dependency instance somewhere, right? Yes, we do. For that we will create a new class TDependencyInjector whose only purpose is to return the right dependency instance. This class will use reflection in order to create the right instance of IDependency. It will use just a string parameter that contains the dependency class name.

uses

RTTI,

Dependencies;

type

TDependencyInjector = class

public

class function GetDependency(aDependencyClassName: string): IDependency;

end;

implementation

{ TDependencyInjector }

class function TDependencyInjector.GetDependency(aDependencyClassName: string): IDependency;

var

RttiContext: TRttiContext;

RttiType: TRttiInstanceType;

begin

RttiType := RttiContext.FindType(aDependencyClassName) as TRttiInstanceType;

if RttiType <> nil then

Result:= RttiType.GetMethod('Create').Invoke(RttiType.MetaclassType, []).AsInterface as IDependency;

end;

Finally, let's put all the pieces together. Consider this console application that puts all the pieces in place:

program DependencyInjection;

{$APPTYPE CONSOLE}

{$R *.res}

uses

...

var

SomeConsumerObj: TConsumer;

Dependency: IDependency;

begin

Dependency:= TDependencyInjector.GetDependency('Dependencies.TDependencyA');

//Dependency:= TDependencyInjector.GetDependency('Dependencies.TDependencyB');

SomeConsumerObj:= TConsumer.Create(Dependency);

try

SomeConsumerObj.GetDependencyType;

finally

SomeConsumerObj.Free;

end;

Readln;

end.

In the code above we get the Dependency instance at runtime by using the TDependencyInjector class. Then we inject that dependency using the constructor of the class TConsumer. We have got a more decoupled design by using dependency injection. Don't you agree? ;-)

Get the full source code of this example here (written in Delphi XE 2).

US Visitor Visa for Permanent Residents of Canada: How to apply online?

2011-10-18T22:44:00.061-04:00

I came to Canada as a federal skilled worker 20 months ago (February 26th, 2010). Since the day I landed I am a Permanent Resident of Canada. I have always wanted to visit the United States of America: so I decided to go for it.

Canadian Citizens do not need a visa to enter the US. In contrast, if you are a permanent resident of Canada (not citizen yet) you might need a visa to enter American soil. I believe the need for a visa relies on the nationality or citizenship you hold. In any case, I am Cuban and Cubans need a visa. If you, like me, need a visitor visa to enter the States from Canada, this is the ABC…

Visitor Visas allow you to enter the US temporarily: that’s why they are called nonimmigrant visas. These visas come in two flavors:

Business Visitor Visas (B-1)
Pleasure, Tourism, Medical Treatment - Visitor Visas (B-2)

In my case, I applied for a B-2 visa, since the purpose of my visit to the US is mainly recreational.

Step 1: You need to fill an Online Nonimmigrant Visa Electronic Application, Form DS-160. Don’t get scared for the name. You simply go to this website and fill in the information required as you go. There is a lot of information that you need to provide. If you need to stop one day, then you can resume the filling process at the next day.

In this step you will be asked to upload a recent digital picture(s) of the applicant(s). There are specifications for the pictures somewhere on the Internet, but I didn’t bother to find them. I just went to the nearest Black’s facility and told them that I needed a US Visitor Visa picture. They know the specifications, since they are a professional photo service. At the end, they shot the picture and burned it into a CD for me (all this in 15 minutes). The cost (tax included) was $22.59 CAD.

When you complete your application you will be presented a confirmation page. You have to print that confirmation page and present it at the time of the interview. The confirmation page contains a bar code that should be legible; so make sure you have a good printer at hand.

Important: you need to complete step 1 before proceeding to step 2.

Step 2: You need to pay a fee for your visa application and then you have to schedule an appointment for your visa interview. The fee for a B-2 visa is $160 USD (it was $140 USD prior to Friday, April 13, 2012, but not anymore). To fulfill this step you need to login (register) at this website: http://usvisa-info.com/en-CA/selfservice/login

Once longed into your account you will need to provide some basic information and then, you should be able to pay your visa fee online (Paypal, Credit Card) and schedule the interview (you have to choose date, time and place). It is not mandatory to pay online; for a full list of fee payment options consult this URL: http://usvisa-info.com/en-CA/selfservice/us_fee_payment_options

You will be asked to print a receipt after you have completed the fee payment. Make sure you print this receipt, since you will have to present it at the time of the interview.

When you complete step 2, the website will give you the option to print a summary of the interview scheduling. Print it, since I was asked for it the day of the interview.

What do you need to bring the day of the interview?

A passport valid for at least 6 month beyond the applicant's intended period of stay in the US.
Your Canadian Permanent Resident card.
The confirmation page with the bar code (step 1).
The receipt of your visa fee payment (step 2).
The summary of the interview scheduling (step 2).
All the documents you think might support your case (in my case I gathered my work contract, bank statements, payroll stats, tax notice of assessment)

Take a look at the existing comments: there’s a lot of useful information in there that complements what I have written in the body of this post.

Please, note that I am a regular person, not an immigration or legal advisor. I am only posting here the facts about my own experience.

If you think this article is useful; would you mind recommending it by clicking the Google Plus (G+) button at the beginning of the post? Thanks!

Decorator Design Pattern in Delphi. Multiple Decorations

2011-09-22T12:25:00.023-04:00

In my previous post I introduced the decorator design pattern to you. I used a fairly simple example (a silly example if you wish) in order to give you a flavour of the pattern. I wrote Delphi code for that matter and I focused in having ONE, and only ONE, decorator class.

This was the situation in the original example: we implemented a TConsole class with a Write method that writes a text to the standard output. Then, we used a TUpperCaseConsole class to decorate a TConsole object. The decoration itself was simple: uppercasing the text to be shown.

Now I want to add a second decoration, which is framing the text to be shown within a rectangle of asterisks (*). For that I will create a new decorator class: TFramedConsole.

Let’s present a raw piece of code: (We will refine and refactor the code later)

var

MyConsole: TConsole;

begin

MyConsole:= TConsole.Create;

MyConsole:= TUpperCaseConsole.Create(MyConsole); //first decoration

MyConsole:= TFramedConsole.Create(MyConsole); //second decoration

try

MyConsole.Write('Hello World!');

finally

MyConsole.Free;

end;

Readln;

end.

In the code above we added a second decoration. The output for that code should be something like this:

**********************
** HELLO WORLD! **
**********************

This is cool: We can even add the same decoration several times. For example, to provide a double frame we would do something like this:

var

MyConsole: TConsole;

begin

MyConsole:= TConsole.Create;

MyConsole:= TUpperCaseConsole.Create(MyConsole); //first decoration

MyConsole:= TFramedConsole.Create(MyConsole); //second decoration

MyConsole:= TFramedConsole.Create(MyConsole); //third decoration

try

MyConsole.Write('Hello World!');

finally

MyConsole.Free;

end;

Readln;

end

Can you guess the output now? It’s like this:

**********************
**********************
** HELLO WORLD! **
**********************
**********************

How are the decorated and decorator classes put together when multiple decorations are needed? There are two key things to remember:

The different concrete decorators (TUpperCaseConsole and TFramedConsole) must inherit from a base decorator class. We will introduce the TDecoratedConsole class as the common ancestor for our decorators.
The base decorator class forwards the calls to its Write method to the decorated object’s Write method.

The code looks like this:

interface

uses

SysUtils, Windows;

type

TConsole = class

private

FText: string;

public

procedure Write(aText: string); virtual;

end;

TDecoratedConsole = class(TConsole) //Base Decorator

private

FConsole: TConsole;

public

constructor Create(aConsole: TConsole);

destructor Destroy; override;

procedure Write(aText: string); override;

end;

TUpperCaseConsole = class(TDecoratedConsole) //Concrete Decorator

public

procedure Write(aText: string); override;

end;

TFramedConsole = class(TDecoratedConsole) //Concrete Decorator

private

procedure CreateFrame(var aText: string);

public

procedure Write(aText: string); override;

end;

implementation

{ TConsole }

procedure TConsole.Write(aText: string);

begin

FText:= aText;

Writeln(FText);

end;

{ TDecoratedConsole }

constructor TDecoratedConsole.Create(aConsole: TConsole);

begin

inherited Create;

FConsole:= aConsole;

end;

destructor TDecoratedConsole.Destroy;

begin

FConsole.Free;

inherited;

end;

procedure TDecoratedConsole.Write(aText: string);

begin

FConsole.Write(aText);

end;

{ TUpperCaseConsole }

procedure TUpperCaseConsole.Write(aText: string);

begin

aText:= UpperCase(aText);

inherited Write(aText);

end;

{ TFramedConsole }

procedure TFramedConsole.CreateFrame(var aText: string);

var

TextLength: Integer;

AsteriskLine: string;

RealText: string;

begin

if Pos('*', aText) = 0 then

aText:= '** ' + aText + ' **';

RealText:= Trim(StringReplace(aText, '*', '', [rfReplaceAll]));

TextLength:= Length(RealText);

AsteriskLine:= StringOfChar('*', TextLength + 10);

aText:= AsteriskLine + #13#10 +

aText + #13#10 + AsteriskLine;

end;

procedure TFramedConsole.Write(aText: string);

begin

CreateFrame(aText);

inherited Write(aText);

end;

I know you are dying to say: the code above is awful because the decorators are bounded to a specific implementation of the decorated class. Indeed, we are going to fix that by introducing a TAbstractConsole class, which will be the common ancestor of the decorated and decorator classes. The TAbstractConsole class is abstract, meaning it has no implementation. You could have used an Interface type instated, something like IAbstractConsole. I’ll leave that to you.

Finally, I present you the consuming code plus the class definition code:

//Consuming code

var

MyConsole: TAbstractConsole;

begin

MyConsole:= TConsole.Create;

MyConsole:= TUpperCaseConsole.Create(MyConsole); //first decoration

MyConsole:= TFramedConsole.Create(MyConsole); //second decoration

MyConsole:= TFramedConsole.Create(MyConsole); //third decoration

try

MyConsole.Write('Hello World!');

finally

MyConsole.Free;

end;

Readln;

end

//Class definition code

interface

uses

SysUtils, Windows;

type

TAbstractConsole = class //Abstract class ==> Interface

public

procedure Write(aText: string); virtual; abstract;

end;

TConsole = class(TAbstractConsole) //Concrete class

private

FText: string;

public

procedure Write(aText: string); override;

end;

TDecoratedConsole = class(TAbstractConsole) //Base Decorator

private

FConsole: TAbstractConsole;

public

constructor Create(aConsole: TAbstractConsole);

destructor Destroy; override;

procedure Write(aText: string); override;

end;

TUpperCaseConsole = class(TDecoratedConsole) //Concrete Decorator

public

procedure Write(aText: string); override;

end;

TFramedConsole = class(TDecoratedConsole) //Concrete Decorator

private

procedure CreateFrame(var aText: string);

public

procedure Write(aText: string); override;

end;

implementation

{ TConsole }

procedure TConsole.Write(aText: string);

begin

FText:= aText;

Writeln(FText);

end;

{ TDecoratedConsole }

constructor TDecoratedConsole.Create(aConsole: TAbstractConsole);

begin

inherited Create;

FConsole:= aConsole;

end;

destructor TDecoratedConsole.Destroy;

begin

FConsole.Free;

inherited;

end;

procedure TDecoratedConsole.Write(aText: string);

begin

FConsole.Write(aText);

end;

{ TUpperCaseConsole }

procedure TUpperCaseConsole.Write(aText: string);

begin

aText:= UpperCase(aText);

inherited Write(aText);

end;

{ TFramedConsole }

procedure TFramedConsole.CreateFrame(var aText: string);

var

TextLength: Integer;

AsteriskLine: string;

RealText: string;

begin

if Pos('*', aText) = 0 then

aText:= '** ' + aText + ' **';

RealText:= Trim(StringReplace(aText, '*', '', [rfReplaceAll]));

TextLength:= Length(RealText);

AsteriskLine:= StringOfChar('*', TextLength + 10);

aText:= AsteriskLine + #13#10 +

aText + #13#10 + AsteriskLine;

end;

procedure TFramedConsole.Write(aText: string);

begin

CreateFrame(aText);

inherited Write(aText);

end;

I hope this was useful and I am definitely waiting for you feedback. Corrections and suggestions are welcome in the comment section below. Thanks!

For further reading about design patterns get your hands on these classics:

Decorator Design Pattern in Delphi. Single decoration

2011-08-26T12:48:00.017-04:00

Decorator (also referred as Wrapper) is classified by GoF as a structural pattern. Its purpose is to:

“Attach additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality.”

Both inheritance and the decorator pattern aim towards extending the functionality. This is what they have in common.

There are a couple of remarkable differences:

Inheritance extends the functionality at compilation time (statically). The decorator pattern extends the functionality at runtime (dynamically).
Inheritance extends the functionality of a whole class (all objects of the extended class get the extended functionality). The decorator pattern allows extending the functionality of a selected object (or group of objects) without affecting the remaining objects.

You can think of the decorator pattern as a way to add make-up to an object or even as a way to attach accessories to that object. All this is done on the fly after the object itself has been created.

Let’s walk through a simple task to get the idea. This example might sound silly. I want it silly so that you can focus on the decorator implementation, avoiding any extra complexity.

Please, be aware that this design is somewhat unfinished, since we are only covering the case for a single decoration (just one functionality to be extended). In real life, we will need multiple decorators in order to add multiple responsibilities. As this is a controlled example (just for the purpose of this discussion), I am enforcing that only ONE responsibility is going to be extended. This means, we will have ONE decorator class. Because of that, I have made some simplifications to the design; so that you get a taste of the decorator pattern in its simplest expression.

Later on, in other post, we’ll see how to add multiple responsibilities (with multiple decorator classes). For that, we’ll need a more complex design to overcome the shortcomings of this initial example. For now, just get the idea...we'll come back later to the multiple decorations scenario.

If you get some time, take a look at the discussion in the comments section.

Subtask 1: Let’s create a TConsole class which purpose is to output a given text to the standard output. The code might be something like this:



interface

type

  TConsole = class

  public

    procedure Write(aText: string);

  end;



implementation



procedure TConsole.Write(aText: string);

begin

  Writeln(aText);

end;

Subtask 2: Let’s use the TConsole class to printout “Hello World!”. The following code snipped does it:



var

  MyConsole: TConsole; 

begin

  MyConsole:= TConsole.Create;

  try

    MyConsole.Write('Hello World!');

  finally

    MyConsole.Free;

  end;

  Readln;

end.

This is how the output looks like:

Hello World!

Subtask 3: Now, let’s decorate the object referenced by MyConsole (only that object, not the whole class). What I want is to upper case every text to be printed out. We need to define a decorator class TUpperCaseConsole for that purpose. See the code:



interface



uses

  SysUtils;



type

  TConsole = class

  public

    procedure Write(aText: string); virtual;

  end;



  //Decorator 

  TUpperCaseConsole = class(TConsole)

  private

    FConsole: TConsole;

  public

    constructor Create(aConsole: TConsole);

    destructor Destroy; override;



    procedure Write(aText: string); override;

  end;



implementation



{ TConsole }



procedure TConsole.Write(aText: string);

begin

  Writeln(aText);

end;



{ TUpperCaseConsole }



constructor TUpperCaseConsole.Create(aConsole: TConsole);

begin

  inherited Create;

  FConsole:= aConsole;

end;



destructor TUpperCaseConsole.Destroy;

begin

  FConsole.Free;

  inherited;

end;



procedure TUpperCaseConsole.Write(aText: string);

begin

  aText:= UpperCase(aText);

FConsole.

Write(aText);

end;

Notice in the code above that the decorator class (TUpperCaseConsole) inherits from the decorated class (TConsole). This makes both the decorated and the decorator objects to share the same public interface. Furthermore, the TUpperCaseConsole class Has-A field of the TConsole type. We’ll use this field to forward the printing functionality to the TConsole class, once we have applied the cosmetic (upper case transformation) to the text.

Subtask 4: Let’s now create some consuming code to decorate one TConsole object on the fly. Note how the TUpperCaseConsole constructor wraps (decorates) the object referenced by MyConsole.



var

  MyConsole: TConsole;

begin

  MyConsole:= TConsole.Create;

  MyConsole:= TUpperCaseConsole.Create(MyConsole);

  try

    MyConsole.Write('Hello World!');

  finally

    MyConsole.Free;

  end;

  Readln;

end.

This is how the output looks like after the decorator has been applied:

HELLO WORLD!

In real life, you’ll have to judge whether the decorator pattern is the best alternative to be applied to solve a particular problem. Not always it the right way to go with. For more details get your hands on these classics books.

Anonymous Methods in Delphi

2011-08-19T13:25:00.013-04:00

Under the scope of Delphi, an anonymous method is either a procedure or function that’s unattached to an identifier. In other words, anonymous methods don’t have names, which is why they are called “anonymous”.

Basically, you can assign a block of code (in the form of a procedure or function) directly to a variable.

I am going to give you a simplistic example. I am going to Keep it simple, Stupid! to avoid distracting you with any complexity.

This is the wording of the task: create a console application which prints “Hello world” and “Good bye” to the standard output. Constraint: use the Writeln function just once in the code.

To accomplish such reckless task in the old days (before the introduction of anonymous methods) you could do this:



program Project1;



{$APPTYPE CONSOLE}



procedure PrintString(aText: string);

begin

 Writeln(aText);

end;



begin

  PrintString('Hello world');

  PrintString('Good bye');

  Readln;

end.

How to do the same with anonymous methods? Take a look at the following code:



program Project1;



{$APPTYPE CONSOLE}



type

  TMyAnonymousProcedureType = reference to procedure(aText: string);



var

  A: TMyAnonymousProcedureType;



begin

  A:= procedure(aText: string) //No semicolon here

                begin

                  Writeln(aText);

                end;

  A('Hello world');

  A('Good bye');

  Readln;

end.

As you can see in the example above, we have assigned code directly to the variable A. Then, we called A with parameters, and Voilà!: we have accomplished our reckless task with anonymous methods as well.

Pay attention to this: if you are tented to declare variable A like this:



var

  A: reference to procedure(aText: string);

Don’t! That shortcut doesn’t work. You’ll get a compilation error…like this:

Undeclared identifier: ‘reference’

So, you do need to declare:



type  

   TMyAnonymousProcedureType = reference to procedure(aText: string);

Only later you can define the type of variable A.

You might be asking by now: why to bother with all this? What's the benefit? Well, in the previous example there’s little or none benefit present.

Generally speaking, anonymous methods are handy in the following cases:

You have been trying to name a local method for hours. You cannot think of a name for it. Well, think no more: use anonymous methods. Don’t put a tasteless name like Foo(), XXX(), Aux(), etc.
You create a function that is called just once(it’s just called from one spot).
You can use anonymous methods to provide elegant and simpler implementations. This is the case when combining generics types with anonymous methods for example. I should write about this shortly. Subscribe to my feed and stay tuned :-)

With this post I wanted to introduce anonymous methods to you. It’s OK if you don’t see the benefits clearly right now. You’ll get there :-)

Hide the utter "Create" constructor of TObject in Delphi

2011-08-15T12:11:00.010-04:00

In Delphi, constructors can be inherited; this doesn’t happen in Java, C# and C++ for example. Furthermore, constructors in Delphi can have multiple and different names; usually they are called Create, but this is just a convention, since you can define a constructor with whatever name you choose.

In addition to all this, all classes in Delphi inherit ultimately from TObject, which contains a public parameterless constructor, named Create.

Due to the facts above, it‘s easy to understand that all classes in Delphi have a public Create parameterless constructor, that has been inherited from TObject.

I am not going to discuss here whether this is bad or good. What I want to show you is a way to hide the public Create parameterless constructor of TObject in case you need to do so.

Burn this out: you cannot hide any member (field, method, constructor, destructor) in Delphi by decreasing the level of visibility. If a member in a superclass is public, you cannot hide it in a child class by changing the visibility to protected or private. Once public you are always public. This means, you cannot hide the public Create parameterless constructor of TObject by lowering its visibility in an inheriting class.

So, how can we hide the Create constructor of TObject? Is there even a way for doing so? Yes, there is a way. We came to the solution in the LinkedIn’s Delphi Professionals group. I thought it would be worthy to share this with the rest of the Delphi community.

Basically, you can hide the public Create parameterless constructor of TObject with another public method having the same Create name. For example:

Class definition snipped:

TSomeClass = class(TObject)

public

//this constructor takes two parameters, and hides the TObject.Create()

constructor Create(aParameter1: string; aParameter2: Integer );

end;

Consuming code snipped:

var

SomeObject: TSomeClass;

begin

SomeObject:= TSomeClass.Create; //This does not compile!

//This compiles. Uncomment and try...

// SomeObject:= TSomeClass.Create('Hello People!', 12);

try

//TODO

finally

SomeObject.Free;

end;

See, in the code above the TObject.Create() has been hidden :-)

There is another consideration though: What happens if we overload the Create constructor?

TSomeClass = class(TObject)

public

//this one takes two parameters, and hides the TObject.Create()

constructor Create(aParameter1: string; aParameter2: Integer ); overload;

constructor Create(aThisTakesAChar: Char); overload;

constructor Create(aThisTakesAnInteger: Integer); overload;

end;

By overloading the Create constructor we have made the TObject.Create() visible again. If we want to keep it hidden, then we should avoid overloading. For that, you can simply use a different name for the new constructors being added. Something like this:

TSomeClass = class(TObject)

public

//this one takes two parameters, and hides the TObject.Create()

constructor Create(aParameter1: string; aParameter2: Integer );

constructor Create2(aThisTakesAChar: Char);

constructor Create3(aThisTakesAnInteger: Integer);

end;

Now the TObject.Create() constructor is hidden again.

Consuming code:

var

SomeObject: TSomeClass;

begin

SomeObject:= TSomeClass.Create; //This does not compile!

//This compiles. Uncomment and try...

// SomeObject:= TSomeClass.Create('Hello People!', 12);

//This compiles. Uncomment and try...

// SomeObject:= TSomeClass.Create1('H');

//This compiles. Uncomment and try...

// SomeObject:= TSomeClass.Create2(12);

try

//TODO

finally

SomeObject.Free;

end;

Why would someone want to hide the TObject.Create() anyway? It depends on the situation. I have found this very useful when implementing a singleton class in Delphi. For details refer to: Singleton class in Delphi.

As a conclusion, you can hide the TObject.Create() constructor by defining a new public method with the name Create in the inheriting class. You cannot hide TObject.Create() by lowering the visibility to protected, private, etc.