def get_current_actions(project_id, status_id = params[:status_id] || DEFAULT_STATUS_ID)
    # implementation goes here
end

The code is saying basically this: “if status_id is not passed explicitly, try to take its value from params array. If it doesn’t contain specified key, then fall back to a constant”. This feature (as almost all the rest of Ruby magic) made avaiable by Ruby’s nature: it is interpreted language. This type of code is totally unusual to guys like me, who come from the world of static typing and compiled languages. But I think I’m gonna get used to it

So, prototype it is. I fired up my Balsamiq for Desktop and in under ten minutes mockups of two pages were ready. This is one of them:

But when I sent them to Elen, I thought that maybe she meant some real code, or HTML stubs in real system, because there was a mockup attached to her original email. Here it is:

According to her, she made it in Paint (duh!). And it took her approximately 30 minutes to make this one, because she had to printscreen some real pages and cut pieces from them. What a tedious work! And it must be a hell to modify such mockup!

When I told her about Balsamiq Mockups, she became very interested and decided to give it a try. Another happy story. Thank you, Peldi

Related posts: Creating UI mockups with Balsamiq

But later at home I was thinking about it and decided that it may not be as hard as it looks. We can divide the task into two subtasks:

• provide a unique color for each user
• use this color when generating markup for an event

The latter subtask was quite easy to implement, I already knew a place where the markup was generated. I was more scared by the former one. If done in “enterprisey” way, it could involve new property in User entity, new configuration screens, database alterations, etc. But there is a solution almost as good as abovementioned and much more simple. Let’s define a function that maps user name to color. md5() is a good candidate

function get_color_by_name($name)
{
    $html_color_string = substr(md5($name), 0, 6);
    return $html_color_string;
}

I also used RGB<=>HSV transformation functions, because I wanted to get lighter colors. Initially I wanted to highlight event’s name with the color, but it turned out that text is not always readable. I decided not to write functions that calculate good contrasting colors and put a small color rectangle instead of highlight. This rectangle is essentially a span with several &nbsp; ’s as a body.

So, final result looks like this:

Here is complete patch (it has too big lines to look good on this page)

And today I am going to tell you about its Calendar feature. My colleagues were wishing it could be easier to share a meeting with others. Yes, sharing is theoretically (and practically) possible. All you have to do is to add selected individuals to your event and they will see it on their calendars in “Shared” section. This sounds like sensible behavior for large companies. However, for a small company like us it is more desirable to have zero-friction sharing. It will bring some informational noise (meetings that don’t really relate to certain individuals), but since we are small company, we can live with it. So, I started looking into the sources and here are my findings. SugarCRM stores association between users and meetings (and other entities, like calls) in join tables, usually named like “meetings_users”. And it uses these tables, when showing calendar. The easiest solution for our problem (zero friction sharing) would be to take that join table out of queries and show ALL meetings. And we will do just that.

Go into <sugarcrm_path>/include/utils/activity_utils.php. In the beginning of the file there will be a function build_related_list_by_user_id. It is used by all calendar routines to extract related events. Find strings:

$select = "SELECT {$bean->table_name}.* from {$bean->rel_users_table},{$bean->table_name} ";
$auto_where .= " {$bean->rel_users_table}.{$bean_id_name}={$bean->table_name}.id AND {$bean->rel_users_table}.user_id='{$user_id}' AND {$bean->table_name}.deleted=0 AND {$bean->rel_users_table}.deleted=0";

And replace them with something like this:

$select = '';
$auto_where = ' WHERE ';
if(!empty($where)) {
    $auto_where .= $where. ' AND ';
}

// Use a simpler query in case of meetings.
if($bean->table_name == "meetings") {
    $select = "SELECT {$bean->table_name}.* from {$bean->table_name} ";
    $auto_where .= " {$bean->table_name}.deleted=0 ";
}
else {
    $select = "SELECT {$bean->table_name}.* from {$bean->rel_users_table},{$bean->table_name} ";
    $auto_where .= " {$bean->rel_users_table}.{$bean_id_name}={$bean->table_name}.id AND {$bean->rel_users_table}.user_id='{$user_id}' AND {$bean->table_name}.deleted=0 AND {$bean->rel_users_table}.deleted=0";
}

Voila! Thas was easy, wasn’t it? And here is unified diff file  for your convenience.

This morning I was about to go to the office. I shut down µTorrent and clicked “Safely remove” on my drive. “This disk cannot be removed right now. I don’t know who uses it, but someone surely is.” was the response. I tried again. The same result. Hmm, maybe some program or explorer window is indeed hanging around. I double-checked all icons on a taskbar, then running processes in Task Manager. Nothing.

“What’s wrong with you?”, I said to the laptop and tried once again. “Now you can safely remove the hardware”. Oh, thank you so much! Why couldn’t you do it the first time I asked you? (And this happens to me on a regular basis, daily. Sometimes, two or three times a day).

As a tech guy I can guess what’s happening. µTorrent opens a lot of files and it probably takes some time to close them and flush all buffers to the drive (which is not very fast, it is external tiny box). Ok, no problem with that. But couldn’t it be done synchronously? I think, Windows can easily recognize situations when some program has open file handles on the drive, or just some file buffers need to be flushed. In the latter case it could show a popup “Removing the drive, please wait…” and do its work. That would leave no space for speculations.

In the other case (when a program uses a disk): is it too difficult to point at the culprit? Some installers can do this. And I am pretty sure there is a 3rd party software that does this. This is pure usability issue. I hope they’ll take care of it in Windows 7.

The “official” way to format strings in .NET BCL is to use String.Format method (and wrappers for it, like Console.Write).

This is not very reliable method. You can forget to include parameter into the format string or confuse one parameter with another. And your IDE does not offer any help here.

We want better way!

People feel that this is not right and try to invent some more convenient methods. One of which is formatting with named parameters (using names instead of ordinals). Yesterday I read this blog post. There are several implementations of formatting with named parameters and author makes more reliable and efficient implementation just for fun. But you know what? It still doesn’t seem right.

Anonymous type here is supposed to protect us from renaming issue, but it clutters the code. And again, we do not get any help from IDE (warnings about non-existing elements, highlighting, etc).

But how can it be done even better?

Let’s look at Nemerle. It borrows “spliced string” syntax from languages like PHP (“hello, $username”). But it has several advantages over PHP and Perl. All expressions are resolved and typed at compile-time. And if you use VS package, then you’ll get development-time checks (on-the-fly) and highlighting.

One picture is worth a thousand words. So look at these code samples

Feel the difference! What can possibly go wrong here (except for NullReferenceException, but string.Format is also vulnerable to it). Also, this code is very efficient. Essentially it is transformed to a series of string.Concat or StringBuilder.Append calls.

P.S.: One more thousand-words-picture.

Why is it bad? Because you either have to have proper development tools that support this decision, or assume high professionalism of the developers, letting them use conventional tools. Good professional developer will be consistent with casing of identifiers, because he sticks to some naming convention and case means something there (this is wild assumption, but I believe it is true, hehe).

Recently I had to fix some ancient program. It is written in Turbo Pascal 5. The IDE is even more useless than even Windows Notepad (can you imagine this?), that’s why I used Notepad++ to edit sources and launch compilation script.

In some recent versions it acquired so-called “smart highting”. This feature highlights all occurrences of a word when you select one of them. Very handy. BUT! it is case sensitive.

Take a look at the screenshot. You can see two occurrences of valor highlighted with green color, but another occurrence is not highlighted, it has different casing. This makes analysis of this source code somewhat harder.

Well, we could blame two sides here: lack of “case sensitivity” options for Notepad++ and this design decision of Niklaus Wirth. I tend to do the latter

In my past experience I have tried different ways of creating mockups:

1. hand-drawn pictures;
2. hand-drawn pictures, photographed with digital camera and inserted into requirement doc;
3. Visio documents (duh!);
4. some actual code.

While the last way serves some extra purposes (other than creating mockup itself), it takes a lot of time. And sometime you just need to share with others a picture you have in your head. Ways #1 and #2 serve very well, but have one major disadvantage: if you want to modify a picture, you have to redraw it from scratch (or make a mess from the original one). And yeah, Visio way does more harm than good: it takes enormous time to create a picture and then you often “forget” to update a mockup, because you don’t want to launch that app again.

So, what options do we have?

Recently I discovered an excellent piece of software, called Balsamiq Mockups. It is simple, effective and nice looking. It requires zero learning time. For example, I tried to create something for my personal project, yet another photo gallery. And I got this mockup ready in exactly 6 minutes after I started the demo:

Impressions: product – great, support – fast and fully satisfying, overall – have to get one.

Also I want to quote Charles William Stanton here:

Before, I was doing far too little GUI “prototyping” because either the results weren’t reusable or the effort took too long; now I fear I may be doing too much because it’s just that much fun.

Go to the product web site and see it for yourself.