Monday, July 30, 2007

Dynamic generation of javascript code

One of the biggest problems for every developer/software architect is the level of generalization/specialization of their code.
If the code is more coupled to the problem , it solves the problem better, but when the problem changes it is harder to change the code. And the oposite .. when the code is more abstract it is easier to change it, but then (generally speaking) the solution is not so good (as it could be in first case).

I am not going to write about the right level of abstraction, because I don’t know it :)
Instead, I am going to write about javascript and some of its interesting features.

Assume that we have the following problem:
We need to write a function that calculates the sum of first n integers.
The first solution that would probably come to everyone’s mind would be the classic for loop that loops from 1 to n and adds value of the counter to some variable..
It could be written as:

function getSum1(n)
var s = 0;
for(var i = 1; i <= n; i++)
s += i;
return s;

This is, of course, totally correct solution, but is it the best one?
Well, it solves the problem.. and is flexible enough to calculate the sum for every given integer.. so, it probably is the best.
What if we know the number that will be passed to the function before it is called?
If so, it would be better if we wrote the function like this:

function getSum2()
return 1+2+3+4+5+6+7+8+9+10;

It would be much faster than the first one.
But, as the beginning of this post says.. it is not flexible. It solves the problem, but it is very coupled to it, so when the problem changes (the number n) it is useless.
We have 2 solutions. Which is better? Well, it depends on the fact how many times is function going to be called with the same parameter, and the importance of the execution speed.

I wrote some tests that can be found here.
There are functions that calculate sum of the first 100 integers, and are called 100000 times.

First one calls the function with the classic for loop (getSum1):

var howManyTimes = 100000;
timeStart = new Date();
for (var i = 0; i<howManyTimes; i++)
result = getSum1(100);
timeStop = new Date();

It then prints duration and the result.

The second test calls the function that generates the code for getSum2 function. After generating , the code is evaluated using the eval function (so the new function is created dynamically):

function createFunction1(val,functName)
var code = "function "+functName+"\n{ \n return 0";
for (var i=1; i<=val;i++)
code += "; \n }";
return code;

timeStart = new Date();
var code = createFunction1(100,"getSum2()");

for (var i = 0; i<howManyTimes; i++)
result = getSum2();
timeStop = new Date();

After that it also prints duration and the result.
And finally the third test generates the function using javascript Function object.

function createFunction2(val)
var code = " return 0";
for (var i=1; i<=val;i++)
code += ";";
return code;

timeStart = new Date();
var code = createFunction2(100);
var getSum3 = new Function(code);

for (var i = 0; i<howManyTimes; i++)
result = getSum3();
timeStop = new Date();

You can see the results of the tests if you run the test file in your browser.
My average results are:

In firefox: getSum1 ~ 4900ms
getSum2 ~ 550ms
getSum3 ~ 450ms
In IE6: getSum1 ~ 4800ms
getSum2 ~ 840ms
getSum3 ~ 740ms

After all this you can say… ok, this is fine, but.. is there any chance that we can use this in real world, in something more complex than the sum of n numbers?
Well, there might be.
Some of today’s most popular java and .NET frameworks (Spring, Spring.NET) use dynamic code generation in their AOP libraries.

I think that in near future some applications could have "smart execution controllers" that would know whether to call an abstract code or to generate concrete code and call it. Especially in applications where performance (speed) is bottle neck.

Friday, July 27, 2007

Trick Google Calendar and send free SMS!

You have probably heard about google calendar's option for sending free SMS notifications about your calendar events.
Some time ago, while playing with google-calendar-data-api , I got an idea to write a program that would allow its users to send sms for free.
Sender and recipient both must have their google calendar account.
Recipient MUST set up her/his account for receiving SMS messages(This can be done in google calendar in "Settings->Mobile Setup") and then for receiving SMS notifications (in "Settings->Calendars->Notifications" check the "New invitations: SMS" checkbox).

So, how it works..
When a sender wants to send sms, she/he enters the text of the message and email address(es) of the recipient(s). Then the program, using google-calendar-data-api, tricks google calendar by creating an event (with no body, just the subject (text of the message)) and invites recipient(s) to that event (by sending the event notification to all email addresses user entered).

After that, the google calendar account of every recipient informs her/him about the event she/he is invited to by sending the sms notification which contains the event's subject.

And that is it.
Google Calendar becomes the free sms service :)

Of course there are some limitations.
Anyone can receive up to 20 messages per day, up to 150 per month. (Number of messages the user can send is unlimited)
The format of the message is: "SENDER'S NAME invites you to: MESSAGE TEXT @time and date"
The sms is sent by google, so my program can't do anything to format it.
The number of the characters for MESSAGE TEXT depends on the length of sender's name.
There are about 60 characters available in my case.
If your text contains more than that number, the program will split the text and create as much the events as necessary and send several sms messages.

The program (written in java) can be downloaded from here

You can't send sms to yourself.