Though Airtel, the biggest private mobile operator in India has not commercially introduced 3G services yet, my 3G USB modem detects Airtel’s 3G signal already in my work city! Looks like they are too close to launch and I really look forward to it! :-)
CellOne is the national operator BSNL which launched 3G last year 2009.
After I watched yesterday’s webcast by Google on Chrome OS, I got a bit curious about their cloud printing thing and thought would give it a test to see if it really works. So, I took the Chrome Browser Dev Channel 9.0.597.10 and setup/enabled Cloud Printing on my home laptop (Windows 7, 64bit) which is connected to my Canon PIXMA printer (via Wi-Fi). The Cloud Print Connector nicely recognized the printer and showed it on the printer management page:
Then from my Mac Book I went to the Cloud Print test page (http://www.google.com/landing/cloudprint/win-enable.html) and fired up a test page to the Canon printer:
When you click Print a test page button, you get to select a printer available on the Cloud Printing enabled PC (in my case in was my home laptop):
The job gets queued, which can be seen back at the printer management page:
After a couple of minutes, Chrome browser on my laptop automatically picks up the test page job and feeds to the selected printer, the job goes to the Completed print jobs list (refresh the above page after a minute or two):
And the test page is this!!
As Google claims, cloud printing is still in early stages and the above UI all subject to change.
I am sure by the time this post appears on my blog site, many around the world would have talked about it, but here are my observations after watching the webcast yesterday by Google.
There are quite a many gems hidden in C# and .NET Framework. Here are some:
C# 2 introduced the concept of nullable value types. If you assign a nullable value type to a non-nullable variable and if the former is null, you will get a runtime error. Meet ?? operator, also known as null-coalescing operator. The operator simply returns a default value when the nullable value type is null otherwise the actual value itself. You can think of it as a specialized ternary operator for nullable-value types.
Again, C# 2 introduced the concept of partial classes, primarily to separate designer-generated code from user-written code so that the designer (Visual Studio’s) can regenerate the code without affecting user’s part. There is one side-benefit too: multiple developers can work on the same class split across multiple files. C# 3 introduced partial methods as an evolvement of partial classes. In short, partial method is one that is declared (without body) but its actual implementation is left to the developer and the implementation is optional. The former aspect may look very similar to abstract methods but the latter is how partial methods differ from abstract methods.
Say you are implementing a business component that performs complex processing. At key stages of this process you want to give the developer an option to do detailed logging or tracing on how the actual logic is running or monitor the code’s performance. In order to do this, you can interleave logging method calls but you do not care how the actual logging is done, if at all it is done. Here is a sample of how the business component class may look like:
The MortgageCore class defines a partial method named TraceMessage which is actually implemented in the subsequent partial class definition. The following shows the reverse-engineered definition of the MortgageCore.IsMortgateRequestValid() method from the compiled output:
Without the partial method implementation, the method looks like:
As you can see, the compiler has removed all the invocations to the partial method after the partial method implementation has been removed. Partial methods may look like delegates too: unless any handlers are hooked, calling a delegate doesn’t have any effect, which is similar to partial method behavior. But again, the C# complier hard-wires delegate calls into assembly while empty partial methods are optimized away without leaving any traces of their existence. Keep in mind the following:
As you might have probably guessed, most of the restrictions are due to the fact that the complier removes partial method references if they are not defined.
Quite popular in dynamic languages like Ruby, duck typing allows the C# compiler to treat a type with characteristics of another type like that type itself (confusing, I know! :-)). Take a look at the sample below:
The class DuckType doesn’t implement IEnumerabe or IEnumerator but has members with the same name as that of those interfaces. This lets the DuckType class to be treated like one that actually implemented these two interfaces and hence can be used in foreach loop:
Produces the output:
Obvious, right?
Well, I have a laundry list of items to cover under this topic and so it might become a multi-part series.