Jamal's Professional Blog

Senior Developers are in Mars

2008-10-19T09:11:00.001+03:30

Last week one of my technical consultation clients (development of network security applications for ISP's and ...) asked if I know someone with great experience in Microsoft .NET with strong VC++ background, and team leadership as well; someone who's willing to manage the mixed C++/.NET development environment.

Well, it did deserve a blog post as it's now 3 different clients who I know are looking for a Senior Developer to manage their development team! And like a recruiter, I've tried finding and recommending someone for the positions, someone preferably from my own professional network with a history (just to be able to give detailed comments), but you know what?! nothing happened and things are just getting worse and worse! I might soon admit experienced senior developers with strong leadership attitude are no longer available; perhaps they're all in Mars now!!!

If you know someone for the positions, please drop me a short line at jamal@mavadat.net (jamal [at] mavadat [dot] net)

Technorati Tags: developer,team leadership

Visual Studio 2010 and MS .NET Framework 4.0

2008-09-30T08:59:00.001+03:30

Yesterday, Microsoft Redmond unveiled the next version of Visual Studio and .NET Framework:

Within last 4 years MS had been so fast on releasing development related stuff! I've seen lots of IT guys arguing this and the way MS is maturing it's framework so fast! Seriously, what do you think?

Technorati Tags: Microsoft,Visual Studio,.NET Framework,VS2010,.NET 4.0

Oracle's Data Warehouse Server

2008-09-25T16:49:00.002+03:30

Although this isn't Oracle's first attempt to enter hardware market, this time it is supposed to be bigger and a bit innovative. Oracle software plus HP hardware, tested by Google. Read more:

Technorati Tags: Oracle,Google,HP,Hardware,Data Warehouse,Server

Entity Framework 3rd Party Providers

2008-08-22T10:33:00.002+04:30

You may have already noticed 11 days back Entity Framework matured out of beta. Luckily, I've already got projects running EF and will be definitely blogging around some best practices and issues later time. But for now, I'm just sharing the following list of soon-to-be 3rd party providers for EF:

Providers Planning Publicly Available Versions in 2008 (Q3 & Q4 CY2008):

Devart (formerly Core Lab) - Providing connectivity to Oracle, MySQL, PostgreSQL and SQLite databases
Firebird - Providing connectivity to Firebird databases
IBM - Providing connectivity to both IBM DB2 data server and Informix Dynamic Server (IDS) database
Npgsql - Providing connectivity to PostgreSQL database versions 7.3+ and 8.x
OpenLink Software - Providing connectivity to OpenLink Virtuoso, Oracle, Informix, Ingres, Sybase, MySQL, PostgreSQL, DB2, Progress and Microsoft SQL Server databases, and any data source accessible via OpenLink ODBC or JDBC bridge drivers
Phoenix Software Solutions - Providing connectivity to SQLite databases
Sun Microsystems - Providing connectivity to MySQL databases
Sybase - Providing connectivity to SQL Anywhere databases
VistaDB Software - Providing connectivity to VistaDB database

Providers Planning Publicly Available Versions in Early 2009 (Q1 CY2009):

Synergex - Providing connectivity to Synergy/DE databases

Providers Committed to Supporting the Entity Framework:

DataDirect Technologies - Providing connectivity to multiple data stores including Oracle, Sybase, Microsoft SQL Server and DB2 via DataDirect Connect® for ADO.NET

Third Party Provider Support for the Entity Framework RTM

Technorati Tags: Entity Framework

String.Empty vs. ""

2008-06-27T20:00:00.003+04:30

Throughout my MS.NET years I was occasionally asked about differences between C# String.Empty and the empty string literal (""). And also when implementing C# and .NET coding-style documents this has always been challenging since everybody has his own opinion, experience, and taste.
A) string s1 = String.Empty;
B) string s2 = "";
Here’s some advice which might come handy:
Performance
String.Empty is a static read-only public field which is initialised by the static constructor of the String class. Simplified MSIL code generated for statement A is ldsfld String.Empty; this simply pushes the reference of a specific field (String.Empty in this case) into local stack of your executing method after invoking static constructor of the class if not previously executed – this is a 5 bytes instruction though. Note that String.Empty field actually assigns the empty literal ("") to a static field only once and during first access to the String class and this is no big deal; then the resulting reference to constant "" value (from string pool - see below) will be reused for your application domain lifetime (your windows process whatever it is, your hosting environment whatever it is…)
On the other hand, the C# statement B results into ldstr "" MSIL statement; again a 5 bytes instruction. ldstr pushes the supplied literal into AppDomain's internal string pool (CLR internal GlobalStringLiteralMap C++ class) if not previously loaded into the map. The reason is obvious: more efficient memory usage by sharing string literals in memory - a technique called string interning.
When comparing the two alternatives, statement A is so straightforward in CLR implementation making it simple and fast, whilst statement B goes through the overhead of checking the AppDomain's string pool (an internal hash-table) bringing very small performance penalty. BUT:

A and B have JIT compile-time differences and JIT-Compiler will eventually generate nearly same results in either cases; this also implies there is absolutely no performance penalty when your assembly [not framework assemblies] is NGENed (using ngen.exe for example)
During JIT-compilation of your executing method there is this very small (nearly zero) performance penalty which is paid only once. In other words, worrying about performance differences between statement A and B is pointless.

Coding Style
Well, whenever it comes to developing an effective coding-style document, I've realised we're not only talking about technology and it also involves aesthetics and human nature! I suppose we all do agree that increasing readability to at least reduce maintenance costs is a generally accepted coding-style design measure; this may hardly become a baseline for coding-style challenges.
What I'll say here, is only my personal opinion and favourite syntax supported by 16+ years of extensive coding effort - yet it does not necessarily reflect community preference: the String.Empty syntax usually results into higher readability by adding distinctness compared to the "" syntax. I'll definitely go for the first one as I feel more comfortable when reviewing and skimming someone else’s code. The "" syntax is not visually clear enough [needs more attention to see whether or not spaces are contained - could make eyes fatigued for very lengthy code]. Also, it is not clear with non-fixed-size fonts where the number of involved spaces matters [in very rare cases – like when using spaces for print or control alignments]. This is because these fonts usually have narrowed space characters not appropriate for extensive coding.

Technorati Tags: C#,.NET,Microsoft,CLR,String Interning

22 Million of Firefox 3 Downloads

2008-06-27T13:39:00.001+04:30

Download record for Mozilla Firefox 3 in the first 24 hours (Download Day) was 8.3 million. By the way, I just got curious what is the download record now few days after the launch date and the result was over 22,560,000 download requests: http://www.spreadfirefox.com/en-US/worldrecord/

And here's more detailed download statistics: http://downloadcounter.sj.mozilla.com/

Have fun...

Technorati Tags: Firefox,Download

Microsoft Distributed Cache - Velocity

2008-06-08T20:23:00.001+04:30

"Velocity" is a distributed in-memory caching platform for building scalable, high-performance enterprise and web data-driven applications. Read More...

Microsoft's "Velocity" is very much similar to memcached (pronounced mem-kash-dee), but Microsoft's "Velocity" has nothing to do with The Apache Velocity Project which is an open-source Java templating platform.

I recommend all scalability, availability, and performance lovers give Velocity CTP1 a test drive.

Vista is Green

2008-06-05T14:30:00.002+04:30

Microsoft Windows Vista™ features a low-power "Sleep" mode whilst the computer is not in use. Sleep allows consumers saving energy as much as shutdown, yet interestingly fast in resume. Sleep is nearly a mixture of XP's Hibernate and Standby features. As in hibernation, it resumes from disk in case of power failure; otherwise, resumes from memory as in normal standby. Surprisingly, sleep performance is consistent enough by the mercy of new Microsoft Superfetch™ technology.

Based on LBNL study on 2002, typical Intel Pentium 4 PC with 17" CRT display consumes 128.5 watts when idle but running. According to EPA, generating 1kw/h of electricity in the US results in 700g of CO2 emissions; therefore, using "Sleep" feature to save energy when not using PCs result in 760kw/h saving, eliminating 534kg of CO2 emissions annually which is equates to 10% of a private vehicle emissions.

Ten of these PCs left on when not in use results in the equivalent of one more car on the road in terms of greenhouse gas contribution annually.

Also based on ICG consulting calculations, 1 acre of forest sequesters 3326kg of CO2 emissions annually. So eliminating 534kg of this amount means 0.161 acres of trees not required.

For every 6 PCs left on when not in use, an acre of trees is required to sequester the greenhouse gas that is released due to generating the power to leave them fully on while not in use.

For more information please refer to VistaEnergyConserv.doc

DG.TV Jose Fajardo on DeepZoom Awesomeness

2008-05-30T12:15:00.001+04:30

Here's a fantastic Silverlight DeepZoom demo by Jose at REMIX08:

C# Covariance and Contravariance

2008-05-29T22:33:00.003+04:30

Overview
As object-oriented programmers we're all familiar with the concepts of covariance and contravariance, however not all programmers are comfortable with such industry-standard terms.

Let's review what they stand for. Take a look at the following code fragment:

class Vehicle
{
}
class Car : Vehicle //a derived class
{
}
void StartEngine( Vehicle v ); //simple method

Contravariance
Sure you know we may be calling the method StartEngine( ) by providing some instances of Car class. Well, it does make sense as we expect compiler implicitly up-cast the Car instances to Vehicle and then invoking the StartEngine( ) method. Yes, this very simple object-oriented technique is called "Contravariance." Contravariance is supported in almost all object-oriented programming languages. In C# 2.0, delegates support contravariance so that programmers see delegate invocations a bit more like normal method calls. Honestly, I think C# designers should had done this by the first version of the compiler, especially considering their implementation didn't require atypical CLR support.

Covariance
And take a look at this method: Vehicle GetMostExpensive( );
It also does make sense for C# programmers to return an instance of Car as the return value of this method. This is simply called "Covariance." Covariance is supported in most OOP languages. In C# 2.0, covariance is supported by delegates in the same way we expect from normal method calls. Again, it could had been available by the first version of C# compiler.

Covariant Arrays
The good news is that C# supports covariant arrays of reference-types. Here we go:

Car[ ] cars = new Car[ 9 ]; //an array of cars
Vehicle[ ] vehicles = cars; //super-type array
object[ ] vehicleObjects = cars; //object array!

Interesting point is that such type casting is 100% supported by CLR and therefore the resulting bits of compilation (.dll or .exe) do not include overheads. However, based on OOP constraints, the real instantiated type of the array is recognised by CLR and prevents adding an instance of non-expected type (String class for instance) to the vehicleObjects array - well, vehicleObjects is a reference which refers to an instance of type Car[ ]. Such attempts result into run-time errors.

But consider how the following code fails during compilation:

int[ ] intArray = new int[ 9 ]; //value-type array
object[ ] objectArray = intArray; //ERROR!

Although CLR supports direct covariant array type casting of reference-types, it doesn't support such behaviour for array of value-types such as int[ ] and DateTime[ ]. Here, I agree with CLR designers who decided not to support such feature as it has conflicts with inline arrays where such simple array casts toggle unintended memory block relocations and new array creation. I personally believe performance and security issues MUST always be visible to developers minimising human mistakes. But the main reason would probably be such casts result into new references which kicks out the whole idea. Not to mention such casts of int[ ] to object[ ] need all members be boxed to their equivalent object reference at first.

Other Covariant Collections
Do you expect the following line of code compile?

List<Car> cars = new List<Car>( ); //list of cars
List<Vehicle> vehicles = cars; //convert!

Nope, it doesn't compile! In fact, there are much differences between a simple array and an instance of List class. Array is directly supported by CLR whilst List is a custom class from CLR's point of view. There are hefty of custom collection classes available out there, and in this case, they all perform the same as .NET Framework's List class does.

Such collection classes (including List class) directly/indirectly rely on CLR's array type and usually contain instance(s) of this primitive array type. Do you really expect List<Car> be implicitly cast to List<Vehicle> as we did by primitive array in which no wrapper class was instantiated? If "yes", How about FileLogger<Car> and FileLogger<Vehicle>, do you still like that cast happen? There are many scenarios where such casts are making you crazy. Simply X<Car> is not of type X<Vehicle> and hence should not be cast!

But still you may realise there are scenarios in which consumers should be able to cast X<Car> to X<Vehicle>. Well, they're not casts in fact. They're simple conversions through which object references are not maintained. Such functionality can easily be supported by adding appropriate methods including conversion operators. However, C# compiler doesn't allow using implicit/explicit operators simulating array conversion (another wise decision), and implementers are to add some normal methods, say List<T>.ConvertTo<SuperType>( ).

Are you happy as implementers of framework's List class have already added ConvertAll( ) generic method?! Hey, don't let it fool you as it's a conversion method helping you "convert" individual entries of the original list to some other type enclosed in a new generic list - it's not a cast-like conversion at all! Actually framework's List implementers haven't added such method, in the sake of complexity it involves for both implementer and consumer developers. As a class library design best practice, it's usually not a good idea having read-write collection wrapper classes for casting purposes! Take a look at code below:

Car[ ] cars = new Car[ 9 ];
Vehicle[ ] vehicles = cars; //implicit cast

if( cars == vehicles ) { } //it's true

List<Car> cars = new List<Car>( );
List<Vehicle> vehicles = cars.UpCast<Vehicle>( );

if( cars == vehicles ) { } //it's FALSE!!!

As you see we've got a conversion (by internal wrapper classes) in which object references are not maintained, however internal primitive arrays are the same CLR objects:

List<Car> cars = new List<Car>( );
List<Vehicle> vehicles = cars.UpCast<Vehicle>( );

if( cars[ 2 ] == vehicles[ 2 ] ) { } //it's true!!!

Though, it seems a missing workaround for the casting problem, it was sound decision not to add such method to List, as it brings further complexities to the code and eventually introduces complicated bugs. At the other hand, UpCast( ) method should return an internal wrapper object (either same or derived type) which delegates all operations to the original instance yet adding performance issues behind the scene in more complicated cases like this:
Dictionary<List<List<Car>>,List<List<String>>>

When converting to:
Dictionary<List<List<Vehicle>>,List<List<object>>>

Summary

Casting and conversion are different as in cast object references are maintained. In other words, when casting no object creation happens but a new view to the existing object is maintained.
C# language designers have not failed not supporting casting from GenericType<B> to GenericType<A> as this is wrong from OOP's point of view
Primitive array cast is supported by both CLR and C#
e.g.: Car[ ] can be cast to Vehicle[ ] - all the references are maintained and no object constructions occur
C# implicit/explicit operators cannot be used to simulate cast-like conversion from same inheritance hierarchy path
.NET Framework designers have not failed not adding cast-like conversion methods to some classes such as List as it has few performance and maintainability consequences. But still more advanced developers could be demanding this from their framework for certain scenarios.

Australia's REMIX08 Momentum Video

2008-05-25T09:42:00.001+04:30

This is the video featured at the beginning of Australia's REMIX08 keynote:

The event was held in Sydney on May 20th, and on May 22nd in Melbourne.

Microsoft CEO Steve Ballmer Gets Egged in Hungary

2008-05-22T01:12:00.001+04:30

Microsoft CEO Steve Ballmer was egged by a protester during a speech he gave at a Hungarian University. Read More...

I've always been pondering how to get best out of worst! By the way, it does worth getting "egged" but be ranked among world's richest guys. Isn't it?!

NineMSDN - Steve Ballmer Egged

And here's some extra:

Steve Ballmer's Monkey Dance:

Steve Ballmer Likes Developers:

Happy Birthday to XML

2008-05-09T18:47:00.004+04:30

Extensible Markup Language (XML) 1.0 Recommendation, is now ten years old since February 10, 2008. In honour to this special occasion, W3C has already launched a very mini-site which you may like to surf...

Cheers everybody,
Not to forget sending your XML 10 Greeting right now...

C# vs. C

2008-04-28T23:01:00.025+04:30

It is pronounced C Sharp, but why is it written C# with the number sign? Why isn’t it written C; with the real musical sharp sign?

C# is Microsoft’s widely known object-oriented programming language. The name is picked from C programming language and Microsoft’s standard programming language, C++ - C plus plus. The latter part (Sharp sign) is selected from the music world; in musical notation, Sharp (), means higher in pitch by a semitone. Sure you have noticed how the name “C++” actually depicts a higher level “C”. And I like the way “C” or “C#” does the same; a beautiful mixture of computer software and music building a name for the new born programming language!

Here is copied from Section 6, Acronyms and abbreviations of ECMA-334 (4th Edition) – C# Language Specification:

“The name C# is written as the LATIN CAPITAL LETTER C (U+0043) followed by the NUMBER SIGN #(U+0023)”

As you notice, it is stated that the official name of the language is C# by using number sign. The number sign (#) was selected by Microsoft to replace the musical sharp sign, and that's some outcome we’re all now familiar with.

The decision was made in the sake of the technical difficulties in displaying the musical sharp sign () which is not supported by all fonts, browsers, and applications; and also the fact that it is not easily accessible by keyboards. The surprising part is that Microsoft sometimes uses the original name (using musical sharp sign) in some ads and arts; just have a brief look at this shot from Microsoft Visual C# 2003 boxes:

Some Background
C# was publicly announced at the Microsoft’s Professional Developers Conference (PDC) in 2000. The lead designer and architect of C# programming language is the famous Danish software engineer, Anders Hejlsberg, who joined Microsoft at 1996, and was very famous for his developments in Turbo Pascal and Delphi – Borland’s amazing development tools at the time. Microsoft offered Anders a bonus of $1,000,000 to join Microsoft. One year later, Borland lodged a complaint that Microsoft has hired some of Borland employees to take Borland’s secrets. Fortunately, the story had a happy ending at last, especially for developers like me who were passionate about both parties.

In August 2000, Microsoft, Hewlett-Packard, and Intel submitted the C# programming language to European Computer Manufacturers Association (ECMA), and at the end of the day ECMA released ECMA-334 – C# Language Specification in December 2001. It was then passed to the International Organization for Standardization (ISO) in 2002, and so it became an ISO standard in 2003 – ISO/IEC 23270. Currently the best standard-compliant implementation of the standard C# is Microsoft C# Compiler, which is actually being employed by some IDE’s such as Microsoft Visual C# and Borland C# Builder.

The very beginning!

2008-04-10T09:22:00.001+04:30

This is the professional blog of Jamal Mavadat. It is dedicated to computer science, and software engineering and development.

This blog is not supposed to be updated very frequently - every other month based on a rule-of-thumb estimation. Anyway, I recommend you subscribe to the Atom/RSS syndication feed of this blog for your convenience: http://blog.mavadat.net/atom.xml, http://blog.mavadat.net/rss.xml

Everybody please feel free to post your comments; however, I'll be so much pleased if you let me moderate.

Best regards,
Jamal