Amazedsaint's Tech Journal

May be this is the best time for Microsoft to Open Source the .NET Framework

noreply@blogger.com (Anoop Madhusudanan) — Wed, 15 May 2013 17:36:00 +0000

Just read a thoughtful post from OdeToCode / Scott Allen – Where is .NET headed.

Scott wrote,

If your business or company still relies solely on components delivered to developers through an MSDN subscription, then it is past time to start looking beyond what Microsoft offers for .NET development so you won’t be left behind in 5 years. Embrace and support open source.

At least, that’s how I see things.

As I commented there, the best move Microsoft could make at this point, with respect to .NET is - to Open Source the .NET Framework. And then launch a program like Apache Incubator around to promote ‘real’ OSS initiatives around the .NET ecosystem.

I believe, the real problem with .NET ecosystem is the unavailability of serious frameworks for solving new age problems - .NET developers are cramped with the non-availability of Proven libraries for Machine Learning, Distributed Processing, Text Processing etc. - Talk about Hadoop, Solr, Lucene, Mahout, Storm, OpenNLP etc - All written in Java and is continuously maturing, despite the fact that Sun started screwing the Java community. The .NET ports for some of these libraries bit the dust long time back, or has very little adoption compared to their prominence in Java ecosystem.

Microsoft is now trying to bridge this gap by bringing in platforms like Hadoop to Azure, and building bridges around the same for .NET interoperability.

CLR and C# are awesome - but MS just can't push forward the development of mature libraries around the same to keep up with the pace of OSS initiatives. The true future of .NET lies in the hand of OSS community at large. Hopefully, if Azure turns out to be a big success story, then Microsoft won't mind open sourcing the Entire .NET stack ;). As Scott pointed in his article, Azure and related hosted offerings (like Office365) + Windows 8 could become the focus points for Microsoft’s revenue.

It is heartening to see that a number of frameworks like ASP.NET MVC, MEF, EF etc already got Open Sourced. But Microsoft can do better in the OSS world to ensure .NET ecosystem will grow further. I believe a lack of buy in from OSS community at large is there –and Microsoft could reduce the friction a little bit by open sourcing .NET.

Hack Raspberry Pi – How To Build Apps In C#, WinForms and ASP.NET Using Mono In Pi

noreply@blogger.com (Anoop Madhusudanan) — Tue, 16 Apr 2013 14:19:00 +0000

Recently I was doing a bit of R&D related to finding a viable, low cost platform for client nodes. Obviously, I came across Raspberry Pi, and found the same extremely interesting. Now, the missing piece of the puzzle was how to get going using C# and .NET in the Pi. C# is a great language, and there are a lot of C# developers out there in the wild who are interested in the Pi.

In this article, I’ll just document my findings so far, and will explain how develop using C# leveraging Mono in a Raspberry Pi. Also, we’ll see how to write few minimal Windows Forms & ASP.NET applications in the Pie as well.

Step 1: What is Raspberry Pi?

Raspberry Pi is an ARM/Linux box for just ~ $30. It was introduced with a vision to teach basic computer science in schools. How ever, it got a lot of attention from hackers all around the world, as it is an awesome low cost platform to hack and experiment cool ideas as Pi is almost a full fledged computer. More About R-Pi From Wikipedia.

The Raspberry Pi is a credit-card-sized single-board computer developed in the UK by theRaspberry Pi Foundation with the intention of promoting the teaching of basic computer science in schools. The Raspberry Pi has a Broadcom BCM2835 system on a chip (SoC),^[3] which includes anARM1176JZF-S 700 MHz processor (The firmware includes a number of "Turbo" modes so that the user can attempt overclocking, up to 1 GHz, without affecting the warranty),^[4] VideoCore IV GPU,^[12] and originally shipped with 256 megabytes of RAM, later upgraded to 512MB.^[13] It does not include a built-in hard disk or solid-state drive, but uses an SD card for booting and long-term storage.^[14] The Foundation's goal is to offer two versions, priced at US$25 and US$35.

Another good introduction from Life Hacker is here

Step 2: Setting up your Development Environment

Let us have a quick look at setting up the development environment.

If you have a physical Raspberry Pi

Raspberry Pi boots from an SD Card. Basically, this means you can transfer an operating system image to an SD Card, and boot your Pi from there. The Raspberry Pi download page lists multiple OS images you can use to load your SD Card. You will need to unzip it and write it to a suitable SD card using the UNIX tool dd. Windows users should use Win32DiskImager. There is a simple guide about how to setup your SD card if you are wondering how to do this. Then, you can connect your Pi device to the TV using an HDMI cable, and can hook up an old USB keyboard to start hacking.

Though multiple images are available in the below mentioned download page, please note that at this point only the Soft-float Debian “wheezy” image can be used to install Mono with out issues. This is because Mono doesn’t support hard-float for Raspberry Pi (simplified version) and some runtime methods like DateTime won’t work if you are using a hard float version. So, you need to download the Soft-Float Debian image and transfer the image file to the SD card. If you feel a bit adventurous, you can try this hard-float port of Mono for the Pi, but it is not supported.

If you don’t have a physical Raspberry Pi

You can still download one of the images from the download page and boot from an emulator like Qemu, which supports ARM architecture.

Get If you are on Windows and if you are not familiar with Qemu, you can download this pre-packaged version of Qemu + Raspberry Pi from here – How ever there is a problem. The Image file that comes with this download is the Hard float version. As we need Mono to work properly, download the Soft-Float Debian Wheezy image – and copy that to the Qemu folder, and modify run.bat in qemu folder to the below command line to point it to the correct image. (If you downloaded Qemu and Soft Float Debian Wheezy image separately, you can create a handy run.bat). Note that as of this writing, the image Soft float image is 2012-08-08-wheezy-armel.img – You need to modify this accordingly. The –cpu switch specify the CPU architecture, –hda attaches the image as the boot device and –m specifies the memory. I’m allocating ~~512~~ 256 MB to my virtual machine. (Note: Updated the command line to use 256 memory based on the comment from Peter below)

qemu-system-arm.exe -M versatilepb -cpu arm1176 -hda 2012-08-08-wheezy-armel.img -kernel kernel-qemu -m 256 -append "root=/dev/sda2"

Step 3: Booting the Pie And Installing Mono

Once you boot the Pie, enter the username and password based on the image/distribution you are using (user/password is normally pi/raspberry). Now, to install mono, we’ll use the apt-get package manager. Let us update and upgrade all the packages before we proceed with the install. Run apt-get with admin permissions, using sudo in the console/terminal.

Each of the below command will take a bit of time - so make sure you've a pressure ball around. And let the force be with you for a successful installation #lol.

sudo apt-get update --fix-missing

sudo apt-get upgrade --fix-missing

sudo apt-get install mono-complete --fix-missing

Step 4: Writing C#

Assuming you’ve got the installation right - Time to write a little bit of C#. Mono has a CSharp command line (REPL), you can bring it up by typing CSharp. So, just play around. If you are setting this up to teach CSharp to kids in schools (original Raspberry Pi vision), the force is stronger in you than you think (Sorry, HBO is now re-telecasting all the old Star Wards stuff). What ever. Here is my CSharp console. Note that if your DateTime.Now is behaving madly, you never read my above paragraph and you’ve got the wrong OS image.

Step 5: Write And Compile Your Code – A Windows Forms app

Quit the CSharp console (quit) and start the Window manager by typing ‘startx’ – Never mind if you are already there. This should bring up the Raspberry Pi desktop. Now, let us create a CSharp file using Leaf pad, a light weight editor in the Raspberry Pi. Either in Run or in a terminal window, type

sudo leafpad /opt/windowapp.cs

And type in some code. Let us create a quick Windows forms application to ensure this is possible in Mono in the Pi.

Now, let us compile the code using the mono compiler (gmcs). Ensure that you are providing the reference libraries we are importing using the /r switch. This should produce the windowapp.exe executable.

Cool. Now time to run it via Mono. This should display a tiny window with width and height 100 – You can drag the corners to see the little Window we created. From here onwards, it is your normal .NET style. Add controls, build apps and have a blast.

Step 6: Installing The XSP Web Server For Some ASP.NET Love

Let us now install Mono XSP server so that we can run some ASP.NET code in the Pie, to use it as a tiny web server. Let us get the XSP bits using apt-get. Fire up your terminal, and type

sudo apt-get install mono-xsp2 mono-xsp2-base asp.net-examples

Which should install XSP.

Cool, you got the XSP installed. Now, let us try some ASP.NET stuff in the Pi. Create a new aspx file in /opt folder using Leafpad, as we did earlier. Here is my aspx file, a simple aspx file I copied from Startdeveloper as I was lazy.

Save the file to your /opt folder, and And start XSP2 in the opt folder. Run XSP2, and open the Internet->Browser and navigate to http://localhost:8080 – You see, it works.

Conclusion

In this post, we explored how to setup Mono to build and run .NET Win forms and Web applications in the Raspberry Pi. Build a computer to learn .NET and C# for under 40$, huh. Follow me in twitter @ https://twitter.com/amazedsaint – Happy Coding.

BIG DATA for .NET Devs: HDInsight, Writing Hadoop Map Reduce Jobs In C# And Querying Results Back Using LINQ

noreply@blogger.com (Anoop Madhusudanan) — Thu, 28 Mar 2013 18:26:00 +0000

Azure HD Insight Services is a 100% Apache Hadoop implementation on top of Microsoft Azure cloud ecosystem.

In this post, we’ll explore

HDInsight/Hadoop on Azure in general and steps for starting with the same
Writing Map Reduce Jobs for Hadoop using C# in particular to store results in HDFS.
Transferring the result data from HDFS to Hive
Reading the data back from the hive using C# and LINQ

Preface

If you are new to Hadoop and Big Data concepts, I suggest you to quickly check out

There are a couple of ways you can start with HDInsight.

You may Go to Azure Preview features and opt in for HDInsight and/or install the same locally

Step 1: Setting up your instance locally in your Windows

For Development, I highly recommend you to install HDInsight developer version locally – You can find it straight inside the Web Platform installer.

Once you install the HDInsight locally, ensure you are running all the Hadoop services.

Also, you may use the following links once your cluster is up and running.

Goto http://localhost:50030 to see the HDInsight dashboard locally
Goto http://localhost:50070 to explore the HDFS file system

Here is the HDInsight dashboard running locally.

And now you are set.

Step 2: Install the Map Reduce package via Nuget

Let us explore how to write few Map Reduce jobs in C#. We’ll write a quick job to count namespaces from C# source files Earlier, in a couple of posts related to Hadoop on Azure - Analyzing some ‘Big Data’ using C# and Extracting Top 500 MSDN Links from Stack Overflow – I showed how to use C# Map Reduce Jobs with Hadoop Streaming to do some meaningful analytics. In this post, we’ll re-write the mapper and reducer leveraging the the new .NET SDK available, and will apply the same on few code files (you can apply that on any dataset).

The new .NET SDK for Hadoop makes it very easy to work with Hadoop from .NET – with more types for supporting Map Reduce Jobs, For creating LINQ to Hive queries etc. Also, the SDK provides an easier way to create and submit your own Map Reduce jobs directly in C# either to the local developer instance or to Azure Hadoop cluster.

To start with, create a console project and install the Microsoft.Hadoop.Mapreduce package via Nuget.

Install-Package Microsoft.Hadoop.Mapreduce

This will add the required dependencies.

Step 3: Writing your Mapper and Reducer

The mapper will read the input from the HDFS file system, and the writer will emit outputs to HDFS. HDFS is Hadoop’s distributed file system, which guarantees high availability. Checkout the Apache HDFS architecture guide for details.

With Hadoop SDK, now you can inherit your Mapper from the MapperBase class, and Reducer from the ReducerCombinerBase class. This is equivalent to the independent Mapper and Reducer exes I demonstrated earlier using Hadoop streaming, just that we’ve got a better way of doing the same. In the Map method, we are just extracting the namespace declarations using reg ex to emit the same (See hadoop streaming details in my previous article)

    //Mapper
    public class NamespaceMapper : MapperBase
    {
        //Override the map method.
        public override void Map(string inputLine, MapperContext context)
        {
            //Extract the namespace declarations in the Csharp files
            var reg = new Regex(@"(using)\s[A-za-z0-9_\.]*\;");
            var matches = reg.Matches(inputLine);

            foreach (Match match in matches)
            {
                //Just emit the namespaces.
                context.EmitKeyValue(match.Value,"1");
            }
        }
    }

    //Reducer
    public class NamespaceReducer : ReducerCombinerBase
    {
        //Accepts each key and count the occurrances
        public override void Reduce(string key, IEnumerable<string> values, 
            ReducerCombinerContext context)
        {
            //Write back  
            context.EmitKeyValue(key,values.Count().ToString());
        }
    }

Next, let us write a Map Reduce Job and configure the same.

Step 4: Writing your Namespace Counter Job

You can simply specify your Mapper and Reducer types and inherit from HadoopJob to create a job class. Here we go.

   //Our Namespace counter job
    public class NamespaceCounterJob : HadoopJob<NamespaceMapper, NamespaceReducer>
    {
        public override HadoopJobConfiguration Configure(ExecutorContext context)
        {
            var config = new HadoopJobConfiguration();
            config.InputPath = "input/CodeFiles";
            config.OutputFolder = "output/CodeFiles";
            return config;
        }
    }

Note that we are overriding the Configure method to specify the configuration parameters. In this case, we are specifying the input and output folders for our mapper/reducer – The lines in the files in input folder will be passed to our mapper instances, and the combined output from the reducer instances will be placed in the output folder.

Step 5: Submitting the job

Finally, we need to connect to the cluster and submit the job, using the ExecuteJob method. Here we go with the main driver.

class Program
    {
        static void Main(string[] args)
        {
            var hadoop = Hadoop.Connect();
            var result=hadoop.MapReduceJob.ExecuteJob<NamespaceCounterJob>();
        }
    }

We are invoking the ExecuteJob method using the NamespaceCounterJob type we just created. In this case, we are submitting the job locally – if you want to submit the job to an Azure HDInsight cluster for the actual execution scenario, you should pass the Azure connection parameters. Details here

Step 6: Executing the job

Before executing the job, you should prepare your input – in this case, you should copy the source code files in the input folder we provided as part of the configuration while creating our Job (see the NamespaceCounterJob). To do this, fire up the Hadoop command line console from the desktop. If your cluster is on Azure, you can remote login to the cluster head node by choosing Remote Login from the HDInsight Dashboard.

Create a folder using the hadoop fs –mkdir input/CodeFiles command
Copy few CSharp files to your folder using hadoop fs –copyFromLocal your\path\*.cs input/CodeFiles

See I’m copying all my CS files under BasicsRevisited folder to input/CodeFiles.

Now, build your project in Visual Studio, open the bin folder and execute your exe file. This will internally kick start MRRunner.exe and your map reduce job will get executed (The name of my executable is simply MapReduce.exe). You can see the detected file dependencies are automatically submitted.

Once the Map Reduce job is completed, you’ll find that the combined output will be placed in output/CodeFiles folder. You can issue the –ls and –cat commands to list the files and view the content of the part-00000 file where the output will be placed (Yes, a little Linux knowledge will help at times ). The part-00000 file contains the combined output of our task – see the name spaces along with their count from the files I submitted.

Step 7: Loading data from HDFS to Hive

As a next step, let us load the data from HDFS to Hadoop Hive so that we can query the same. We'll create a table using the CREATE TABLE hive syntax, and will load the data. You can run ‘hive’ command from the Hadoop command line to run the following statements.

CREATE TABLE nstable (
  namespace STRING,
  count INT)
ROW FORMAT DELIMITED
FIELDS TERMINATED BY '\t'
STORED AS TEXTFILE;

LOAD DATA INPATH 'output/CodeFiles/part-00000' into table nstable;

And here is what you might see.

Now, you can read the data from the hive.

See my article Querying data from the Hive using LINQ and C#
I wrote a VS Add In so that you can connect to Hive and query the data

And there you go. Now you know everything about writing your own Hadoop Map Reduce Jobs in C#, load the data to the Hive, and query the same back in C# to visualize your data. Happy Coding.

Reflection API Changes in .NET 4.5 Applications and Fun with Custom Reflection Context

noreply@blogger.com (Anoop Madhusudanan) — Mon, 25 Mar 2013 13:06:00 +0000

Before .NET 4.5, as you are aware, the Type class in System namespace was used for most of the reflection scenarios. Though you can use Type class to inspect meta data, this is really heavy weight. As most reflection scenarios are just read only (for example, using attributes for providing meta data etc), Microsoft decided to introduce a light weight, alternate Type API as part of .NET Core profile. If you are wondering about different .NET profiles, here is a good list compiled together.

Type and TypeInfo

So to keep the long story short - in .NET 4.5 onwards, Type class got ‘shrunk’ to provide a shallow, high speed read only view of an object’s structure (definition). And TypeInfo class got introduced that contains the actual type definitions with more detailed information. See Type and TypeInfo – and check out the platform specific support for it’s members. You can read more about the Reflection API changes here

The TypeInfo class represents type definitions and the Type class represents type references. Given a Type object, you can get the name of the type as a string, without any requirement to load anything more. Alternatively, if you need rich information about a type, you can get a TypeInfo object from a Type object.

In .NET full profiles used for desktop and web applications, the old Type API (Accessing everything through Type) is still available to maintain backward compatibility, along with the new Type API (TypeInfo etc). And For .NET Framework profiles for new platforms like WinRT that don’t need backward compatibility, Type class got shrunk by removing a number of members as discussed, and TypeInfo is the only way to dive deep into reflection. If you are writing code that should target multiple framework versions (as in Portable Class Libraries), you should use the new API. Otherwise, you can continue to use the old API as .NET framework versions on full profile actually returns the self contained Type object as previously.

Using TypeInfo

You may call GetTypeInfo on any type object as shown below to get the TypeInfo for a Type, and may use the new API (like DeclaredProperties) to traverse the members.

	//Get the basic type
        Type myType = "somestring".GetType();

        //Get more information about that type
        TypeInfo myTypeDetails = myType.GetTypeInfo();

        foreach(var prop in myTypeDetails.DeclaredProperties)
            {
                Console.WriteLine(prop.Name);
            }

Also, you may use TypeInfo to check the relations between types. For example, here is how to use IsAssignableFrom method of TypeInfo to determine variance.

  //Can I assign a string to an object - True
   var canAssignStringToObject = typeof (object).GetTypeInfo()
                                  .IsAssignableFrom(typeof (string));

  //Can I assign an object to a string - False
  var canAssignObjectToString = typeof(string).GetTypeInfo()
                                 .IsAssignableFrom(typeof(object));

Custom Reflection Context

Custom Reflection Context is a new addition in .NET 4.5, to customize how a consumer using the TypeInfo based new Reflection API views reflected information about your types. This will be extremely helpful when you write Libraries and design components that take advantage of meta data. This is much like customizing Type information using techniques like type descriptors. The new API provides run time virtualization over reflection, and looks quite intuitive - I wish this was there when we spend years writing custom tools for extending Visual Studio few years back, to virtualize type information for existing and new components.

You can override properties in CustomReflectionContext to add virtualized properties, custom attributes etc. For example, here is a quick PropertyAdder context that’ll inject some properties while accessed through the custom reflection context

    //Just a dummy Dog class
    //See that we don't have any properties
    class Dog
    {

    }

//A PropertyAdder context
    //To add custom properties to the reflection context
    class PropertyAdder : CustomReflectionContext
    {
        private readonly Dictionary _properties;

        public PropertyAdder(Dictionary properties)
        {
            _properties = properties;
        }

        protected override IEnumerable AddProperties(Type type)
        {
            if (type == typeof(Dog))
            {
                foreach (var p in _properties)
                {
                    yield return
                        CreateProperty(MapType(p.Value.GetType().GetTypeInfo()),
                                       p.Key,
                                       (o) => _properties[p.Key],
                                       (o, v) => _properties[p.Key] = v);
                }
            }
            else
            {
                base.AddProperties(type);
            }
        }
    }

And here is a quick example for using our PropertyAdder. Essentially,

We are creating a new instance of PropertyAdder
Then decorating our Dog class’s type information by mapping the type information via the custom reflection context.
Finally, we are creating an instance of Dog class, and look ma- we’ve got the properties via reflection

So, here we go.

    //Main Driver
    class Program
    {
        static void Main(string[] args)
        {

            //Properties we want to add
            var properties = new Dictionary
                {
                    {"Name", "Joe"},
                    {"Age", 10}
                };

            //An instance of our custom reflection context
            var adderContext = new PropertyAdder(properties);

            //Get the type in the default reflection context.
            var dogTypeInfo = typeof (Dog).GetTypeInfo();

            //Get the type in the customized reflection context.
            //We'll map the context with our PropertyAdder
            var customDogTypeInfo = adderContext.MapType(dogTypeInfo);


            //Just an instance
            var d = new Dog();

            //Display properties and values using custom reflection context. 
            foreach (var prop in customDogTypeInfo.DeclaredProperties)
            {

                //We'll really see the properties we added above
                Console.WriteLine("{0}={1}",prop.Name, 
                    customDogTypeInfo.GetProperty(prop.Name).GetValue(d));
            }

            Console.ReadLine();
        }
    }

And here is the output. You’ll see that we are accessing the properties we added via the reflection context. Here you go.

So this is fun especially when you work with libraries that leverage meta data and on the tooling side. For example, the RegistrationBuilder class in MEF 2.0 inherits custom reflection context to provide meta data based conventions that describes rules for decorating entities.

Happy Coding . Also, see my other C# posts here

Azure Hadoop HDInsight Tools – Wrote A VS Add In For LINQ To Hive Model Generation and Hive SQL Queries

noreply@blogger.com (Anoop Madhusudanan) — Fri, 08 Mar 2013 13:21:00 +0000

This post is about the HD Insight Tools Visual Studio Add In - for accessing Azure Hadoop Hive from Visual Studio. I hacked together the same on my way back from the MVP summit, and a post is due. If you are new, last week I wrote about issuing LINQ queries against the Hive meta store – read that post for a general introduction about LINQ to Hive.

You may use HDInsight Tools Visual Studio Add In for

Generating wrapper classes for Hive tables for easily executing LINQ to Hive queries.
Running Hive SQL queries from Visual Studio and for viewing the results

Please note that you need to provision a Hadoop cluster in Azure, or need HDInsight installed locally (See these earlier posts related to Hadoop on Azure - Analyzing some ‘Big Data’ using C# and Extracting Top 500 MSDN Links from Stack Overflow ).

Installing The Add In

You can install the Add In from Visual Studio Tools –> Extensions and Updates.

Generating LINQ To Hive Model Classes

Once you install the Add In, Goto View-> Other Windows –> Hive Explorer to bring up the Hive Explorer tool Window. Click Add Connection to add a hive connection, by providing the server details, port, user name and password and click Save.

Once you add a connection, you can expand the connection to view the tables and fields in the Hive. Now, you can right click on the Added connection name in the tool Window, and click ‘Generate Code’ context menu to generate the model classes. Also, make sure you install the Microsoft.Hadoop.Hive nuget package by issuing the install-package Microsoft.Hadoop.Hive –pre nuget command.

You can use the generated model to query Hive using LINQ as mentioned in the previous article.

Issuing Queries

You can use the Queries window of Hive Explorer to issue Hive Queries. Choose the connection in the combo box, and shoot your query to view the results.

Happy Coding. I’m soon uploading the source code of Hive Explore to Github after some clean up once I’ve some time.

About That ‘Feelings’ In Software Industry

noreply@blogger.com (Anoop Madhusudanan) — Wed, 06 Mar 2013 18:47:00 +0000

When I read Built to Last few years back, I got stumbled upon this fact – it is all about building a cult. And a cult is not a bad thing. You can base it on some ethical values, and can sprinkle stories and sutras around the same to make it more exciting. Or, you may brand it as your corporate culture. But in the end of the day, it is all about building a cult which looks original and rallying your employees and customers around the same with out shaking their belief.

In the last ten years, Steve Jobs did that much better than any one else. I think he learned about the art of creating a cult when he was wandering in India, may be from Neem Karoli Baba. Today, people worship Apple.

I believe successful organizations are good in assembling together such a framework that can yield repeatable behavioral patterns from all stakeholders, most importantly, customers. Any successful organization need at least one iconic leader with charisma to grow beyond mediocrity. People buy a brand not just because of its usability – They buy or act when they believe in the cult of the brand, when they buy in to that ideology and find the trust.

As Simon points out in this Ted Talk, great leaders inspire action – they inspire employees and customers and other stake holders to align with the cult or self of the organization. I think the justification for all this lies deep with in, we are wired to follow a cult. For example, our feelings and instincts influence a purchase decision – probably much more than the numbers we have in our head.

So, I believe everything from Brand loyalty to architecture decisions are influenced by aspects like peer recommendations and herd mentality in a big way. That’s why a number of CXOs invest in ‘Big Data’ and ‘Cloud’ with out knowing the intricacies.

Even software has it’s FADs right now. So, it is of no surprise that the industry is also driven by its own fashions and styles at times. Some of these FADs will burst as bubbles. Who cares. The world works on chaos theory, and it is not really predictable all the time – so decisions based on gut feeling and intuitions are acceptable to some extent, isn’t it? Though, generally I don’t recommend subjectivity over objectivity.

AutoCommand For MVVM – More tricks With Lambdas and CallerMemberName

noreply@blogger.com (Anoop Madhusudanan) — Tue, 05 Mar 2013 20:55:00 +0000

Few days back I ranted about Lamdba Patterns in C# and Init Time branching. I also had a generally insane example regarding Init Time branching using CallerMemberName attribute, and got few comments about the usefulness (or the lack of the same).

While I generally agree with the comments, here is a may be useful, still crazy AutoCommand for your next basement MVVM application. First, here is how the AutoCommand will work.

//Our simple View Model
public class SimpleMathViewModel : BaseViewModel
    {
        public SimpleMathViewModel()
        {
            Commands = new Dictionary<string, Action>
                {
                    {"Add", ()=>Result=A+B},
                    {"Substract", ()=>Result=A-B},
                    {"Multiply", ()=>Result=A*B},
                    {"Divide", ()=>Result=A/B}
                };
        }

        //Your commands should get automatically wired up

        public ICommand Add { get { return new AutoCommand(this); } }
        public ICommand Substract { get { return new AutoCommand(this); } }
        public ICommand Multiply { get { return new AutoCommand(this); } }
        public ICommand Divide { get { return new AutoCommand(this); } }

        //Other blah blah properties
        public int A { get; set; }
        public int B { get; set; }

        private int _result;
        public int Result
        {
            get { return _result; }
            set
            {
                _result = value; OnPropertyChanged();
            }
        }
    }

Also, Look ma, there is no dirty property name string in the OnPropertyChanged method call to raise the PropertyChanged notification as it is inferred - but I'm sure you might have read some where else how to use CallerMemberName to do the trick. If you are still wondering, see the method implementation in the BaseViewModel code below.

Leaving that aside – how’z the wiring works for AutoCommand? Alright, guess you guessed it. Here is the AutoCommand implementation.

   public class AutoCommand : ICommand
    {
        private readonly BaseViewModel _instance;
        private readonly string _caller;

        //Just keep the caller name and the base view model instance
        public AutoCommand(BaseViewModel instance, 
                [CallerMemberName]string caller = "")
        {
            _instance = instance;
            _caller = caller;
        }

        public bool CanExecute(object parameter)
        {
            return true; //who cares
        }

        //Fetch the right command to execute from the dictionary
        public void Execute(object parameter)
        {
            _instance.Commands[_caller](); //get the ICommand based on the caller name
        }

        public event EventHandler CanExecuteChanged;
    }

And if you are wondering how we've implemented the BaseViewModel, it is trivial. There only interesting piece there is how we inject the property name to the base class method.

 public abstract class BaseViewModel : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;
        public Dictionary<string, Action> Commands { get; set; }

        protected virtual void OnPropertyChanged([CallerMemberName]string propertyName="")
        {           
            PropertyChangedEventHandler handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }

This is not a best practice show case, was just discussing a language feature and few possibilities. Happy and Insane coding

A Quick introduction to Hadoop Hive on Azure and Querying Hive using LINQ in C#

noreply@blogger.com (Anoop Madhusudanan) — Thu, 28 Feb 2013 03:04:00 +0000

Earlier, in a couple of posts related to Hadoop on Azure - Analyzing some ‘Big Data’ using C# and Extracting Top 500 MSDN Links from Stack Overflow – I showed how to use C# Map Reduce Jobs with Hadoop Streaming to do some meaningful analytics.

Now, a preview version of the .NET SDK for Hadoop is available, making it easier to work with Hadoop from .NET – with more types for supporting Map Reduce Jobs, For creating LINQ to Hive queries etc. You can experiment with Hadoop and C# either by creating a cluster in http://hadooponazure.com or you can obtain Hadoop in your machine by installing Microsoft HDInsight using WebPI.

In case you are new to Hadoop on Azure, I suggest you read the introductory concepts here before you start. This post is just a quick example that shows how to use LINQ to Hive.

Hive is a data warehouse system for Hadoop that facilitates easy data summarization, ad-hoc queries, and the analysis of large datasets stored in Hadoop compatible file systems

Installing the libraries

To start with, you can fire up Visual Studio, Create a console project, and install Microsoft.Hadoop.Hive libraries via Nuget.

install-package Microsoft.Hadoop.Hive -pre

Also, head over to http://hadoopoonazure.com and create a new cluster. And you are now set.

Creating the typed wrappers

To access Hive, you need to create a strongly typed wrapper – as of now, you need to roll this out your own, as there is no automated generation support. When you provision a Hadoop cluster, the Hive will be pre populated with a sample table (hivesampletable), and I’m using the same for the below example for brevity. You can connect to the Hive via ODBC and see the hive tables in Excel.

So, let us go ahead and create a hive connection (much like an EF data context) and a typed representation for a row in the table. HiveConnection and HiveTable types are in the Microsoft.Hadoop.Hive namespace.

    
    //Our concrete hive connection
    
    public class SampleHiveConnection : HiveConnection
    {
        public SampleHiveConnection(string hostName, int port) 
            : base(hostName, port, null, null) { }

        public SampleHiveConnection(string hostName, int port, 
                            string username, string password) 
            : base(hostName, port, username, password) { }

        public HiveTable<DeviceInfo> DeviceInfoTable
        {
            get
            {
                return this.GetTable<DeviceInfo>("hivesampletable");
            }
        }
    }

    //A typed row. Property names based on field names hivesampletable
    
    public class DeviceInfo : HiveRow
    {
        public string DevicePlatform { get; set; }
        public string DeviceMake { get; set; }
        public int ClientId { get; set; }
    }

Querying the Hive using LINQ

Now, you may perform LINQ queries against your Hive context, thanks to the Hadoop SDK we installed via Nuget. Just make sure to substitute the connection string, username and password with your own.

class Program
    {
        static void Main(string[] args)
        {


            //Create a hive connection
            //I've my cluster in https://www.hadooponazure.com
            var hive = new SampleHiveConnection(
                    "saintcluster.cloudapp.net", //your connection string
                    10000,                       //port                    
                    "user",                      //your username
                    "yourpass");                 //your password


            //Get the results
            //Make sure you goto the dashboard and turn on the ODBC port
            var res = from d in hive.DeviceInfoTable
                      where d.ClientId < 100
                      select d;

            //Dump it to the console if you like
            var list = res.ToList();     

        }
    }

That is cool. Your LINQ query will be submitted to the Azure cluster via the ODBC driver, and will be compiled and executed in the Hive.

Book Reviewed - Kinect for Windows SDK Programming Guide By Abhijit Jana

noreply@blogger.com (Anoop Madhusudanan) — Tue, 26 Feb 2013 07:26:00 +0000

Recently, Abhijith Jana published his Kinect For Windows SDK Programming Guide – And I’m one of the three technical reviewers. The Book is very pictorial in the explanations, with crisp code samples and cited annotations. I was particularly impressed with the way Abhijit tied the features of Kinect with Real use cases. The book covers all the hardware and software aspects, with lot of illustrations and examples. I liked the easy to understand, simple narration followed by Abhijit.

The Tone of the book

He starts with unpacking the Kinect, introducing you to the hardware and software components. And in the next couple of chapters, he is slowly familiarizing you to the camera, making sense of the color and depth image streams, Skeleton tracking, Speech API, Gesture detection etc. The book also covers various third party Kinect related APIs (including Coding4Fun Kinect Toolkit, few Gesture Libraries etc).

The last couple of chapters is all about what you can build using Kinect, with some cool examples that demonstrates how to interface Kinect with multiple platforms including Azure, Windows Phone and few Micro Controllers. There are a number of cool graphics/illustrations to enable readers to visualize various aspects like depth detection, gesture detection etc.

About the Content

More importantly, I believe this turned out to be a practical guide for any one to write real world applications using Kinect. One of my observations during the review stage was to include a lot of practical examples. I am glad to see these countless examples in the book and should commend Abhijit for his hard work. There are lot of practical scenarios covered, including

Using Kinect Windows SDK to build gesture capabilities in your Windows applications
Adding night vision using IR sensors
Audio processing
Building an intrusion detector using Kinect
Using Kinect Speech recognizer capabilities to integrate Speech detection
Making Kinect and Netdunio work together to have some serious fun etc.

I recently showed this book to some enthusiasts during my “Natural User Interface using C#” sessions in Rutgers as well as in Cupertino, and the response was quite amazing. As it assumes no prior knowledge in NUIs, this was a good starting point for a number of hackers. Also, one startup I met in CA mentioned that they are building a 3D Scanner in Kinect to use with the 3D printers, by extracting the point cloud and to convert the same to a 3D format that can be passed to the printers.

I may be a bit biased about the book as I was working with Abhi very closely for the review, but I suggest you to have a look at Amazon listing and see the reviews there. Suggest you should buy the same, if you ever tried hacking cool stuff. Or, what about building interactive Advertisement boards using Windows 8? Or a private intrusion detector for your home? Just Go ahead and buy one. – I’m so confident that you’ll love it..

Lambda patterns in C#?

noreply@blogger.com (Anoop Madhusudanan) — Tue, 26 Feb 2013 05:28:00 +0000

I had few interesting discussions during the MVP Summit around using patterns from other programming languages in C#. Earlier, I’ve blogged about some of these scenarios.

I’ve over heard Florian’s session this time during the summit, where he elaborated few interesting patterns from Java script that could be used in C#. He has a pretty good Code Project article regarding the same – Way To Lambda – and it is pretty good to see a formalized approach towards re-using these patterns in C#

One of my favorites is the C# version of Init-time branching (See Javascript Init time branching here)

   enum Mode
    {
        Http,
        WebSocket
    }

    class Messenger
    {

        public Func<string> Read { get; private set; }

        public Messenger(Mode m)
        {
            if (m == Mode.Http)
            {                
                Read = ()=>"Stub read logic using http"; 
            }
            else
            {
                Read = () => "Stub read logic using websocket";
            }
        }
    }

The above is a very simple version of Init time branching – but Instead of setting up the method (in this case the Read method) based on some configuration parameter, you can inject the same via the constructor or to the property – and in this way abstract out the branching as part the DI.

Convention Based Strategy Pattern _

Disclaimer: The remaining portion of the article is just not for regular use cases, and you can easily shoot yourself in the foot.

Now, let us use Init-Time branching to attain some kind of ‘Convention based’ strategy pattern. Branching will be done based on the caller’s semantics. Let us assemble a simple Serializer, that uses some convention based on the caller’s name. Note that we are using the Caller information attributes to extract the caller name.

class ConventionSerializer
    {
        public Func<string> Serialize { get; private set; }

        public ConventionSerializer([CallerMemberName] string memberName = "")
        {
            if (memberName.Contains("Xml"))
            {
                Serialize = () => 
                { /* serialize to xml */
                  return "xml"; 
                };
            }
            else
            {
                Serialize = () =>
                { /* serialize to json */
                    return "json";
                };
            }
        }

    }

And then, you may consume the same from the methods WriteXml and WriteJson.

       static void WriteXml()
        {
            var ser = new ConventionSerializer();
            Console.WriteLine(ser.Serialize()); //output xml
        }

        static void WriteJson()
        {
            var ser = new ConventionSerializer();
            Console.WriteLine(ser.Serialize()); //output json
        }

Was just bringing up an alternate perspective, requesting purists not to get offended. Happy Coding

Portable Library and WinRT support for ElasticObject

noreply@blogger.com (Anoop Madhusudanan) — Fri, 18 Jan 2013 06:19:00 +0000

Read these articles if you are catching up about Elastic Object

Adventures with C# Dynamic – Implementing your own ElasticObject
Creating Test data using ElasticObject

If you loved using my ElasticObject implementation, here is some good news for you

Ariel Ben Horesh recently added Portable Library project type and WinRT support for ElasticObject recently. So, enjoy the wicked evilness of ElasticObject in your Portable Libraries and WinRT projects.

A quick note on Closing lambda loop variables in C# 5.0 - Breaking Changes in C# 5.0 compiler

noreply@blogger.com (Anoop Madhusudanan) — Mon, 17 Dec 2012 05:15:00 +0000

This post is regarding a breaking change in C# 5.0 related to using variables in lambdas with in a loop.

For example, prior to C# 5.0 compiler, the following code

        
     //** Code Example 1 **
 
     static void Main(string[] args)
        {
            var items = new List<int>() { 1, 2, 3, 4, 5 };
            var queue = new List<Func<int>>();
            foreach (var item in items)
                queue.Add(() => item);
            foreach (var q in queue) Console.WriteLine(q());
            Console.Read();
        
    }

will produce the following output

This is because prior the C# 5.0, the compiler closes/captures the reference of the lambda/loop variable than its actual value. And hence the value defaults to the current value at the time of invocation (here, when invoking the q() method) instead of the value at the time of using the variable in the expression (when adding it to the queue). So, earlier, the compiler forced you to declare a local variable in a loop (counter intuitive any day) because if you want to see the expected output, you need to manually close the variable by assigning it to some other variable, like

    //** Code Example 2 **

   static void Main(string[] args)
        {
            var items = new List<int>() {1,2,3,4,5};
            var queue = new List<Func<int>>();
            foreach (var item in items)
            {
                //Prior to C# 5.0 this was required to correctly
                //capture the value
                var val = item;
                queue.Add(() => val);
            }
            foreach (var q in queue) Console.WriteLine(q());
            Console.Read();
        }
    }

And this should give the output as below.

From C# 5.0 onwards, the compiler will capture the value of the variable instead of it’s reference when you use a variable in a lambda expression with in a loop. So, Code Example 1 will provide Output Listing 2 that eliminates the need to capture the value manually, and you can write better code with out being forced to have local variables with in a loop.

‘HTML5 vs. Hybrid vs. Native Dilemma’ When You Build Enterprise Mobile Applications - The Bigger Picture

noreply@blogger.com (Anoop Madhusudanan) — Tue, 27 Nov 2012 18:23:00 +0000

This post is mainly about building Enterprise Mobile applications. Today I was reading Charlie's post about building mobile applications, and was analyzing the hybrid application scenario from an Enterprise Standpoint.

The Bigger Picture

Most of the recent conversations I had about building enterprise mobile applications starts with questions like “Whether I should go Hybrid or Native”. It is true that a lot of organizations are interested to go the ‘hybrid’ way because of cost concerns – but in my opinion, any decision should be customer driven instead of cost driven. So, the answer for this question should be driven by “What will give the best user experience to the end user”, instead or/along with asking questions like “how we can reduce the cost”. This is true for all apps, not just for enterprise mobile apps.

Beyond this, from an Enterprise Standpoint, I think achieving end point independence is another way to reduce your cost and future proof your investments. So, while “HTML5 vs Hybrid vs Native” is just one decision parameter, there are few more parameters to consider when you talk about a mobile strategy. Including,

Concerns during envisioning phase

Target user analysis
Choose a simple framework to begin with, like Forrester’s POST approach
Gap analysis and portfolio rationalization

Deciding a strategy for Mobile Application development & Delivery

Mobile Web/Pure HTML/JS
Hybrid apps (HTML5/JS apps in Native containers - Like Phone Gap and/or native parts/plugs like in Titanium)
Native apps

Concerns regarding a Common Service Layer

Building/Implementing a scalable Common Service Layer
Implementing a scalable broker system between the service layer and legacy systems
Ensuring standards (like using REST)
Identifying and integrating a Content Delivery Network (CDN) for media delivery

Testing Model

Security and Performance
Device based testing

Submission Governance

Payment model
Keep track of submitted applications
Analytics
Feedback tracking
Continuous improvement

So, all these are parts of your mobile strategy. Especially when you talk about Enterprise mobility, achieving Mobile End Point independence is a key concern, and organizations understand the necessity of making their business logic and data available to multiple end points. REST is evolving more and more as a default choice for building a public service layer, around your existing data and intelligence.

Hybrid vs Native

Now, specifically about Hybrid vs Native. Here are the main Pros and Cons as I see it.

For Hybrid applications

Pros:

No need for device specific development
Better ROI as same code base can be re-used (to an extent) across multiple platforms
You can still access some of the device features
Can be packaged for additional channels, (Chrome Packaged Apps, Awesonium)

Cons

UI specialization is difficult
Can’t be as responsive and feature rich as ‘pure’ native applications
May hit limitations when implementing specific, optimized features

For Native Applications

Pros

High degree of customization, can satisfy edge conditions
High degree of usability

Cons

Scattered/multiple platforms
Investment required for each platform
Non unified code base, not much re-usability
Teams with multiple skill sets required

And More

That said, again, think beyond the “Hybrid vs Native” point when you think about Enterprise Mobility.

From a Middleware Perspective

Select a strategy where storage and compute resources of your Mobile apps can reside in Mobile devices, on-premises servers and Cloud computing infrastructure.
Use a brokered service for connecting, communicating and brokering between Mobile apps, on-premise resources and Cloud/Middleware environment.

Custom implementation on top of brokers like Windows Azure Service Bus
Build on a Mobile ready WOA stack like Marlabs Matrix platform
Third party Mobile Middle ware platforms like Syclo etc

Use Cloud based federated authentication services and security systems if you need support for multiple authentication providers – Like Azure Federated Authentication.
Adopt cloud/service based push notification services for sending and receiving notifications from your Mobile devices.
Choose a proper content delivery network that supports bit rate streaming to deliver video content. For example, Azure CDN or Limelight True Reach API.
Enable APIs for provisioning, tracking and feedback reporting.

From a Middleware Perspective

Submission governance includes deciding a proper strategy for payment model, usage tracking, analytics and feedback reporting. The Submission Governance should ensure

Minimum criteria for submitting an application to the app store
Users are heard properly – Feedbacks and ratings should be used for identifying features
Releases and updates are following user expectations

So, happy coding!!

Changing Times For Web Developers – 6 Tips You Should Read To Survive

noreply@blogger.com (Anoop Madhusudanan) — Sat, 24 Nov 2012 07:57:00 +0000

The context of this post is about the changing times for a web developer, and I see a lot of web developers still lagging behind especially in the .NET world. If you haven't yet started mastering your art and adapting to the changing trends, you should start today.

Think about crafting your web applications properly. Use commonsense to mix and match based on scenarios. Here we go with 6 Tips to be a responsible web developer, and to stay on top of what you do.

1 – Learn to write better JavaScript and CSS

If you don’t write proper JavaScript and CSS, you are dead.

Learn the good parts about Javascript
Venture into Advanced Javascript

Familiarize yourself with a higher level abstraction language to write JavaScript once you are comfortable with plain Javascript – Like CoffeeScript or TypeScript. Also, master the common Javascript libraries, including these essentials

JQuery – Alright, you know this, don’t you?
Require.js - A JavaScript file and module loader.
Underscore .js – A pretty good Javascript utility library
modernizr – HTML5/CSS feature detector
history.js – History State/APIs

Oh yes, start learning TypeScript especially if you have a Microsoft technology/C# background.

On the CSS Side, familiarize with SASS and/or Less – Skim through the CSS 3 techniques, keep an eye on the CSS 3 features available in various browsers. Understand responsive concepts and start using media queries.

2 – Familiarize yourself with a Responsive Framework

These days, the usage of web is increasing more and more in mobile devices, so most websites are expected to work in different form factors by default. If you don’t want to hand craft all those web pages using media queries, better familiarize yourself with few responsive frameworks.

Responsive web design (often abbreviated to RWD) is an approach to web design in which a site is crafted to provide an optimal viewing experience—easy reading and navigation with a minimum of resizing, panning, and scrolling—across a wide range of devices (from desktop computer monitors to mobile phones)

My personal choices include Twitter Bootstrap and Zurb’s Foundation. I’ve done quite a lot of work with Bootstrap, and I’m pretty impressed with the capabilities of foundation too.

Essential reads.

3 – Learn the most useful JavaScript MVC frameworks

Be a first class JavaScript developer. There is a jungle of Javascript MVC frameworks out there for client side development, but familiarize yourself with at least five (Yes, at least 5). I’ll pick some of these to start with.

To compare and contrast them, have a look at TodoMVC – I found it pretty useful. It is

A project which offers the same Todo application implemented using MV* concepts in most of the popular JavaScript MV* frameworks of today.

4 – Understand REST and HTTP

Understand Restful services and master a server side technology to create one. For example, Node Js. If you are in the .NET world, start with Web APIs. More than that, understand proper REST. Understand Hypermedia. Go beyond the terms, and carve out some examples. Tie your REST services with one of the above MVC frameworks, and create something useful. Use proper HTTP codes for your services.

Essential reads

The above reads should help, to start with. Also, keep an eye on implementations, like Meteor, SignalR etc that could leverage Web Sockets once they are ready.

5 – Understand HTML5 Beyond the Buzzword

HTML5 standard is not yet finalized and is still in progress, but already there is lot of adoption every where. Along with developing websites, there are lot of containers available (like PhoneGap etc) that’ll allow you to package your HTML5 applications with a browser like container for mobile devices (hybrid applications), to distribute them much like you distribute native applications.

HTML5 is a markup language for structuring and presenting content for the World Wide Web and a core technology of the Internet. It is the fifth revision of the HTML standard (created in 1990 and standardized as HTML4 as of 1997)^[2] and, as of November 2012, is still under development. Its core aims have been to improve the language with support for the latest multimedia while keeping it easily readable by humans and consistently understood by computers and devices (web browsers, parsers, etc.).

There are lot of good articles about HTML5

Step by step article from Nettuts with examples
This article in Smashing Magazine is a pretty good starting point to understand more about the design philosophy and thought processes involved
Top 25 HTML5 Features

Familiarize yourself with the most useful and exciting HTML5 Javascript APIs and features. Like Web Sockets, Application Cache, Canvas API, Vide/Audio features etc. Start using something like HTML5 boiler plate as the baseline. http://www.initializr.com/

Understand the HTML 5 features and value adds you can use.

Here are few quick demos of various HTML5 feautures
Use something like http://html5please.com/ or CanIUse, keep yourself updated about the HTML5 features you can use to improve use cases based on requirements

Also watch for the big players in the space who are leveraging HTML5 as a platform for building cross platform hybrid applications – not for web, but also for desktop and mobile.

6 – Optimize

Optimize what ever you do, optimize when you are ready.

Bundle and minify your CSS and Javascript.
Use some developer tools to inspect your page and check your JavaScript performance
- Google Chrome’s speed tracer
- YSlow
Inspect your network traffic when required and this will come in handy every time– Familiarize with tools like Fiddler
Use tools like Screenfly to check your screen for multiple form factors
Use simulators like Ripple for checking the behavior of your websites in Mobile devices

Alright, that was lot of tips. So, happy coding.

Meet Ms. Roslyn – Article in DNC Magazine

noreply@blogger.com (Anoop Madhusudanan) — Sat, 24 Nov 2012 05:40:00 +0000

I wrote a couple of articles here about Ms. Roslyn earlier. Roslyn provides language services and APIs on top of .NET’s compiler services, and this will enable .NET developers to do a lot more things – including

Using C# and VB.NET as scripting languages
Use compiler as a service in your own applications for code related tasks
Develop better language and IDE extensions etc.
Write code analysis and manipulation tools around Visual Studio IDE

See my previous articles on Roslyn

So, I was more than happy to contribute when the Amazing Dotnet Curry Magazine team reached out to me for an article on Roslyn. Go, download and subscribe the DNC Magazine here. It is a free Magazine, and kudos to the great work from Suprotim, Sumit and team for the awesome work they are doing for the community by bringing this out. You can get the magazine issues for free here.

Happy Coding!!

Why I’m truly excited about Windows 8 – It is all about connecting the dots

noreply@blogger.com (Anoop Madhusudanan) — Thu, 25 Oct 2012 10:52:00 +0000

I think the true pitch of Microsoft is all about connecting the dots – Read a stable cloud platform, a plethora of PaaS offerings, A truly modern and fresh operating system that works seamlessly across multiple form factors, proper interfacing with existing devices like XBox – and all this working together.

If you are reading this before the Windows 8 launch event – You can watch it live here today (25th October 2012).

Windows 8 versions include

Windows 8 (Normal, Pro and Enterprise versions) that runs on Intel and AMD processors

This will be available with most of the PCs, Desktops and hybrids. This can run legacy Windows applications as well along with Metro applications. Has got both Metro and Desktop interfaces.

Windows RT that runs on ARM chipsets

This version is mainly for tablets, a stripped down version of Windows that can’t run legacy applications. Though this also has a desktop mode, the desktop mode will only support touch optimized Office 2013 apps.

As of now, Microsoft’s own Surface device is available with Windows RT, and a version with full Windows 8 will be available soon.

It is all about Connecting the dots

Make no mistake, today’s Windows 8 release is something that I’m truly excited about. But I’m more excited about the way Microsoft played all these strings together to create a symphony with all their different technologies, to create a connected and co-syncing user experience across devices and platforms - and I think they got it right this time. Along with this, add all the back end and front end platforms (and integrating points) they have for developers to create truly magnificent applications for both enterprise and consumer markets.

This enables a lot of possibilities. Like using my Windows 8/Win RT tablet or phone as a remote control. Like using your television as a second screen for your Tablet. Like chatting about a movie with your friends when you watch it.

See this Smart Glass Video

This wave of releases from Microsoft will connect all your screens together – PCs, TVs (X Box), Tablets, and Phone (Yea I know, it might take few months for Windows Phone to reach there eventually to provide full Win RT support).

Few key un seen ingredients people miss when they talk about the pitch from Microsoft include

A properly baked cloud ecosystem with enough PaaS and SaaS offerings in the backend to co-sync user experiences for both enterprise and consumer market (Azure, Office 365, Sky drive etc)
Proper interfacing of Windows 8 with devices like X Box to provide seamless user experience (Smart Glass)
Easy integration and up gradation for enterprise customers

A number of devices to choose from

It was a good move from Microsoft to raise the bar with it’s own Surface tablet. Windows 8 enables lot of hardware manufacturers to experiment with new generation hybrid devices, and I believe this new set of Windows 8 PC/Tablet/Laptop convertibles are awesome, and provides a lot of options when you want to pick your Windows 8 or Win RT device. You are not just locked in to Microsoft’s own Surface tablet (Though I may buy one) and it’s form factor.

You have a lot of form factors to choose from, based on what you need. For example, see this 20 inch marvel from Sony.

The productivity factor

I always struggled with my iPad to do serious stuff – When I want to create good presentations, edit documents, and check and reply to my mails. Windows 8/Win RT along with Microsoft Outlook and Office Suite should take my worries away.

The app ecosystem as of now is not as large as what iOS is having – for good and bad. As a developer, I think it is good because my applications will get noticed soon in the Windows market place. As an end user, may be having lot of apps is a good thing – though I’m more interested in quality rather than quantity anyway.

The enterprise features finally will enable a controlled BYOD strategy for enterprises to bank on – so far they were ducking away from the Android and iPad tablets due to the lack of seamless integration with existing IT infrastructure. So I can see my enterprise customers caching in on Windows 8 devices for productivity boost.

Type Script Language Features – Classes, Inheritance & Overriding

noreply@blogger.com (Anoop Madhusudanan) — Fri, 05 Oct 2012 17:46:00 +0000

Type Script brings a lot more structure and object oriented goodness to JavaScript, thought under the hood it is just a Syntax sugar for JavaScript. This article uncovers some basic Object Oriented Programming concepts introduced by Type Script, that will wrap the ‘bad parts’ of JavaScript under the carpet so that you can write better code.

I suggest you read my post “An Introduction To Type Script” before you read this article.

In this post, Let us explore few features about Classes, Inheritance and Method Overriding in TypeScript.

Classes in Type Script

Classes in TypeScript closely resembles the ECMA proposal according the the language specification. Classes can have private or public members.

Let us start with a very minimal Animal Class in Type Script. Our Animal class also got a parameterized constructor, that takes name as an input to store it in the 'name' variable of type string, when the instance gets created.

//Our Animal Class
class Animal {

    //Name 
    public name: string;

    //Animal Constructor
    constructor (name: string) {
        this.name = name;
    }

    //A Method, the scope is public by default. ‘this’ points to the class instance
    sayName() {
     
         var span = document.createElement("span");
         span.innerText ="My Name Is" + this.name;
         document.body.appendChild(span);
    }

}

//Let us do something in onload
window.onload = () =>
{
   //Create an instance of Animal
    var a = new Animal("Tommy");
	
   //Invoke the method	
    a.sayName();
}

You should see the message from the sayName method, "My name is Tommy".

Parameter property declaration

In the above example, you could find that we are accepting the ‘name’ parameter via a constructor, and then assigning that to a property with name ‘name’. TypeScript has a short cut notation to declare properties with the same name and value as the constructor parameter. For this, you can prefix a constructor parameter with either ‘private’ or ‘public’, so that a property will be declared for you. The below code is functionally equivalent to the above code, see that we are not declaring the property explicitly though it is getting created for us.

//Our Animal Class
class Animal {

    //Animal Constructor. Note that I’m having a 
    //public specifier to the parameter
    constructor (public name: string) {
        //Look ma, I'm not explicitly declaring
        //or assigning to a name
    }

	//A Method, the scope is public by default
    sayName() {
        //The name property is created for you, so you can
        //access this.name
         var span = document.createElement("span");
         span.innerText ="My Name Is" + this.name;
         document.body.appendChild(span);
    }
}

//Let us do something in onload
window.onload = () =>
{
	//Create an instance of Animal
    var a = new Animal("Tommy");
	
	//Invoke the method	
    a.sayName();
}

Run this now, and you should get the same output as the previous one. That was interesting, right?

Inheritance & Overriding

Now, let us quickly explore some inheritance concepts in Type Script. Consider a simple example where you are inheriting a Dog class from the Animal class. You can use the 'extends' key word to extend from a base class. You can also override methods. A derived class will inherit all public members from it’s base class.

//Our Animal Class
class Animal {

	//Animal Constructor
    constructor (public name: string) {
    }

	//A Method, the scope is public by default
    sayName() {
         var span = document.createElement("span");
         span.innerText ="My Name Is" + this.name;
         document.body.appendChild(span);
    }
}


//Let us inherit Dog from Animal
class Dog extends Animal {

    //Override sayName method with some other logic, as usually dogs bark before 
    //saying their name ;)
    sayName() {
         var span = document.createElement("span");
         span.innerText ="Bow Bow, My Name Is" + this.name;
         document.body.appendChild(span);
     }
}

//Let us do something in onload
window.onload = () =>
{
   //Create an instance of Dog and store in an Animal variable
    var a: Animal = new Dog("Tommy");
   //Invoke the method, this will invoke sayName() in Dog class	
    a.sayName();
}

Now, a.sayName() will invoke the sayName(..) method in Dog class. Now, how will you down cast an instance of Dog from variable a of type ‘Animal’ back to a variable of type Dog?

//Create an instance of Dog and store in an Animal variable
var a: Animal = new Dog("Tommy");

//This will result in an error as what ever you stored in a can be a some other type
//inherited from Animal instead of dog.
var d: Dog = a;

This is how to downcast properly, checkout the <type> syntax

   
//Create an instance of Dog and store in an Animal variable
var a: Animal = new Dog("Tommy");
//Downcasting by ensuring a proper type
var d: Dog = <Dog> a;

‘super’ Keyword

You can use the super keyword in the constructor of a derived class, to pass the parameters to the base class constructor. Super calls for passing parameters are not allowed outside the constructor in TypeScript, though you can use super keyword to invoke methods of the base class from the derived class. Here is a quick example. See that we are passing the name to the base class constructor from the derived class constructor. Also note that we are using parameter property declaration to declare properties with the same name and value as constructor parameters, as explained above.

//Our Animal Class
class Animal {
	//Animal Constructor
    constructor (public name: string) {
    }
}

class Dog extends Animal {
      //Dog Constructor

      //We are leveraging parameter property declaration
      //to automatically create name and age properties
      constructor (public name: string, public age:number)
      {
        //Note that we are passing name to the 
        //base class constructor to initialize
        super(name);
      }

    sayHello() {
         var span = document.createElement("span");
         span.innerText = "Hello, I'm " + this.name + " with age " + this.age;
         document.body.appendChild(span);
     }
}

//Let us do something in onload
window.onload = () =>
{
  
    //Create an instance of Dog 
    var d: Dog = new Dog("Jim",20);    
    //Make the dog say hello
    d.sayHello();
   
}

Other than using Super for passing constructor parameters to base class, you may also use super for invoking methods in base class - like super.methodName() from methods in your derived class. I intentionally missed covering few other interesting aspects including Modules, Interfaces, Function Overloading, Function types etc - that is for another post.

Stay tuned, and subscribe now.

Microsoft TypeScript : A quick introduction and A Love Affair Begins here.

noreply@blogger.com (Anoop Madhusudanan) — Mon, 01 Oct 2012 18:39:00 +0000

Alright, I knew this was coming. At least, I inferred. When I went to Microsoft few months back to attend the MVP summit, we had an awesome session from Anders, and I asked him what is the future of C#. He muttered something like “JavaScript is the true cross platform language” (Did I hear that right?)

And there was some speculation that Anders was working on something related to JavaScript. And now, Typescript is here. TypeScript is a neat little language that compiles in to JavaScript, and the compiled output is readable and pretty printed it seems, so that you can use the compiled JavaScript directly where ever you want. I played around with Typescript, and it looks pretty neat (Yea, I’m repeating the term ‘neat’). The syntax has some magical similarity to the aesthetics of C# (or that was my feeling?). I’ve seen few people wondering whether TypeScript is Microsoft’s version of Dart or whether it is some kind of Coffee Script on Steroids – but after trying TypeScript out for sometime, I’m in love with Typescript. I was making some notes, and combined them for this blog post.

You can install Typescript from here , and then in Visual Studio, try creating an HTML application with Typescript. (OSS Fans Cheer up, Support for VI, Sublime and Emacs is also available)

A Quick Hello World in TypeScript

Here is a quick hello world script I wrote using Typescript. You can see the type script file (app.ts), and the generated app.js file. As I mentioned, the syntax is very much similar to C#. And the big surprise – as the name indicates, TypeScript supports ‘Types’. See my HelloWorld class below, I’m having a constructor which takes an HTMLElement, and I’ve got a sayHello method that accepts a message of type string. I feel having these type contracts will be a big boon because that’ll help programmers to specify expected types for a function.

Here is the Typescript code, and generated Javascript code. While working in Visual Studio, I’ve noticed that Visual Studio Typescript editor provides type inference, that’s cool. See my HelloWorld class – pretty self explanatory.

//Our TypeScript HelloWorld class

class HelloWorld {
    
    //A variable of type HTMLElement
    element: HTMLElement;

    //A Consctructor that accepts an element
    constructor (e: HTMLElement) { 
        this.element = e;
    }

    //A public method
    sayHello(message: string) {
        this.element.innerHTML = message;
    }

}

window.onload = () => {
    var e = document.getElementById('content');

    //Initiate HelloWorld Class
    var hello = new HelloWorld(e);
    hello.sayHello("Hello World");
};

Awesome. Now, here is the generated Javascript code, that's equivalent to the above Typescript code. Neat and clean generation.

var HelloWorld = (function () {
    function HelloWorld(e) {
        this.element = e;
    }
    HelloWorld.prototype.sayHello = function (message) {
        this.element.innerHTML = message;
    };
    return HelloWorld;
})();
window.onload = function () {
    var e = document.getElementById('content');
    var hello = new HelloWorld(e);
    hello.sayHello("Hello World");
};

You can even use scope keywords in your TypeScript class - try making the element variable private, and sayHello method public. I also skimmed through the Type Script specification, and here are few other interested points I noticed apart from the Types support.

Function Types

Typescript uses Function Types for handling call backs. Let us modify the above code, to have a call back. See that I've added a notify parameter to our sayHello method of type

(feedback : string)=>any

This simply represents a function which takes a an input parameter of type string, and returns ‘any’ back to the caller (See ‘any’ type below). Upon the completion of sayHello, we are calling the notify(..) back, which will invoke the function(..) we passed to sayHello from window.onload – This is almost like passing a Function over a delegate type and invoking it back in the C# sense..

//Our TypeScript class now with Callbacks

class HelloWorld {
    
    //A variable of type HTMLElement
    element: HTMLElement;

    //A Consctructor that accepts an element
    constructor (e: HTMLElement) { 
        this.element = e;
    }

    //A public method. See notify paramter is now taking a Function Type
    sayHello(message: string, notify: (feedback : string)=>any ) {
        alert(message);
        //Do some other complex stuff here
        notify("completed sayHello");
    }

}

window.onload = () => {
    var e = document.getElementById('content');

    //Initiate HelloWorld Class
    var hello = new HelloWorld(e);
    hello.sayHello("Hello World", function (feedback) {
            alert(feedback);
        }
    );
};

Run the project, fire up the HTML page, and you’ll see the first message box with “hello world”, and second message box with “completed sayHello” message. Pretty cool. We just learned how to write type safe call backs in TypeScript, elegantly, with out worrying about closures

Object Types

An Object type looks like { parameter1: type1, parameter2: type2, … }. Example is

{name: string, age: number}

You can give a name to an object type, like this.

 interface Human 
   {
    name: string, 
    age: number
   }

Once you define an interface, you can use it as a contract, for specifying input, for return types, for call backs etc, with full Intellisense support. See below.

A Bit more about Types in Typescript

TypeScript has multiple types. Here is a quick overview

‘any’ type

“Any Type is a super set of all types”

Example:
- var x : any; //x is explicitly typed to any
- var y; //type of y is any by default as no other type is specified

Primitive Types

TypeScript supports number, bool, string, null and undefined

Example
- Number
  - var num : number;
  - var num = 20; //number type will be automatically inferred for num variable, same as var num : number = 20
- String
  - var name : string;
  - var message=”hello”; //string type will be automatically inferred for message variable
- Bool
  - var isOpen : bool;
  - var isEnabled=true; //bool type will be automatically inferred for isEnabled variable

‘void’ type

Used as the return type of functions that don’t return any value

Object Types

This include class, interface, module and literal types. These Object types contain one or more

Properties
Call signatures (Parameters and return types associated with a call operation)
Construct signatures (Parameters and return types associated with applying the ‘new’ operator)
Index signatures
Brands (Brands are categories the given object type belongs to)

More about this later. Examples
- Object obj = {name : “Vinod”, age: 30 };
- Function square = (x: number)=> x * x; //Almost like the lambda syntax in C#

Conclusion

Overall, I found that there is a strange attraction factor that connects C# developers with Type Script. I was able to start with out much hassle, and was able to grasp the basics in a couple of hours. Of course, introducing types ( CLARIFIED: i.e, types for enabling well defined contracts for functions, input parameters, return types etc) on a meta level and still maintaining the dynamic feature of JavaScript is a big thing as this means better refactoring, easier maintainability and better documentation. Enjoy TypeScript, I’m pretty sure I’ll write more about this pretty soon. I’m in love with Typescript.

Update: Checkout the second part, Type Script Language Features – Classes, Inheritance and Overriding >>

Introducing SignalWire – Magical Plumbing with your Data Store + C# and LINQ in your HTML pages

noreply@blogger.com (Anoop Madhusudanan) — Sat, 29 Sep 2012 15:44:00 +0000

SignalWire is an experimental Server<->Client plumbing project I started, that magically wires up your HTML5 front end to the collections/tables in your data store or ORM, and I just pushed the first commit to Github. SignalWire uses SignalR and Roslyn libraries to implement features like

Exposing collections in your Back end directly over the wire for CRUD operations and for performing LINQ queries from your JavaScript.
Enable using C# in your HTML applications.

I got inspired by Meteor and started SignalWire as a POC to implement some of these features on the .NET stack, but I’ve got few more ideas on the way and thought about pushing this to Github. See the codebase in Github

Check out this quick video (no sound, sorry), a simple Taskboard built using SignalWire. See how we are accessing the collections in Javascript, and check how we are issuing LINQ queries

As of now, support is available for EntityFramework and MongoDb as the back end. Also, it provides

A light weight permission framework (wip)
A Client side Javascript API to access your collections with minimal/no serverside code
Model Validation support using normal C#/ASP.NET Data Validation attributes
LINQ support to issue Linq queires from HTML pages (highly experimental, as of now no sandboxing support per caller)
C# code in your HTML pages (wip)

How To Start

You may start with Creating an Empty ASP.NET Project in Visual Studio 2012 (You need .NET 4.5 as we are using Roslyn September CTP libraries). Then, install SignalWire using Nuget. In Package Manager console

Install-Package SignalWire

This will add the following components to your project.

Models\TaskDb.cs - An example Entity Framework Data Context. You can use your instead
Hubs\DataHub.cs - An example Datahub.
Scripts\SignalWire.js - Clientside JQuery Pluin for SignalR.

Now, goto Index.html, and verify all your JS file versions are correct. Run the application and see

Server – Data Context and Hub

The Only server side code you need is your POCO objects and a hub inherited from the DataHub base class, which is defined in the SignalWire library. You need to use the Collections attribute to map a POCO class with the set/collection, and make sure you always do that in lower case.

   //Simple POCO class to represent a task
    [Collection("tasks")]
    public class Task
    {
        [Required]
        public int Id { get; set; }

        [Required]
        [MaxLength(100, ErrorMessage = "Subject cannot be longer than 40 characters.")]
        public string Subject { get; set; }

        [Required]
        [MaxLength(200, ErrorMessage = "Details cannot be longer than 40 characters.")]
        public string Details { get; set; }

        public bool Completed { get; set; }
    }


   //Simple demo db context   
    public class TaskDb : DbContext
    {
        public DbSet<Task> Tasks { get; set; }
    }

Now, you need a hub. By convention, Wire assume’s the server hub’s name as Data if it is not specified in the init method of $.wire.init(..). In the example you get when you install the Nuget package, you’ll see we are using an Entity Framework Context Provider, for TaskDb which is a DataContext. Replace TaskDb with your own EF Data context if required. Once you do that, all your collections/sets with in the context can be accessed over the wire. In the example, you’ve only on set in your TaskDb data context as you can see above - that is Tasks. Let us create the Hub.

public class Data : DataHub<EFContextProvider<TaskDb>>

That's all you need to access collections via the Wire.

Client - Initializing and Issuing Queries

SignalWire magically exposes all your Tables/Sets/Collections in your Data back end via the $.wire Javascript object at client side. You can initialize $.wire using the init() method, which returns a JQuery Deferred. Here is a quick example regarding initializing Wire and issuing a LINQ query.

     //Initialize wire
     $.wire.init().done(function () {

      //Now you can access the tasks collection in your data context
      //You can issue a LINQ Query.
      $.wire.tasks.query("from Task t in Tasks select t")
               .done(function (result) {
                    $.each(result, function (index, task) {
                       //Do something with each task
                    });
                }).fail(function (result) {
                    alert(JSON.stringify(result.Error));
                });
         });

Other Wire Methods

You can use $.wire.yourcollection.add(..) to add objects to a specific collection. The add method will return the added item with updated Id up on completion.

    var t = {
        "subject": $("#subject").val(),
        "details": $("#details").val(),
    };


    //Add a task to the Tasks collection                    
    $.wire.tasks.add(t)
       .done(function (task) {
          //Note that you'll get the auto generated Id
       }).fail(function (result) {
            //result.Error contains the error if any                        
            //result.ValidationResults contains the Validation results if any 
            alert(JSON.stringify(result.Error)); 
       });

Similarly, you can use

$.wire.yourcollection.remove(item) to remove items
$.wire.yourcollection.update(item) to update an item (based on Id match).
$.wire.yourcollection.read({"query":"expression", "skip":"xxx", "take":"xxx"}) to read from a specific collection

Permissions

You can decorate your Model classes with Custom permission attributes that implements IPermission. This will check if the user in the current context can actually perform a specific operation on a Model entity.

What's More

I'm planning the following features based on my time

Sandboxed execution for C# scripts in HTML page that can access client side context
Publishing and data sync
Permission based events, may be using something like PushQA.

Fork on Github to play around

Roslyn September CTP 2012 Overview – API Changes, Using Modified APIs for C# Script Execution, Embedding C# as a scripting language

noreply@blogger.com (Anoop Madhusudanan) — Wed, 19 Sep 2012 10:00:00 +0000

Microsoft Roslyn September CTP 2012 is now released. You can download the September CTP here

You could find a quick overview about Roslyn in my previous overview post.

Roslyn CTP previews the upcoming features of C# and VB.NET. Roslyn CTP is a pretty exciting release, and it opens up lot of possibilities for C# and VB.NET programmers. Roslyn provides language services and APIs on top of .NET’s compiler services, and this will enable .NET developers to do a lot more things – including using C# and VB.NET as scripting languages, use compiler as a service in your own applications for code related tasks, develop better language and IDE extensions etc.

What’s Exciting In September CTP (CTP3) release

One of the biggest excitement for me is the support for Expression Trees. This means, now you can include LINQ Queries in your script, and you can dynamically execute LINQ queries. This has lot of interesting aspects, and this is huge. For example, see how I’m executing a very simple Linq query from the C# interactive console.

Along with inclusion of Expression trees, the following language features are also now supported in Roslyn, since CTP2.

Collection initializers
Extern aliases
Multi-dimensional arrays
Nullable types
Object initializers
Type forwarders
Unsafe code (except fixed-size buffers)

Scripting API Changes

There are some breaking changes in September CTP release. I thought I’ll quickly re-phrase the Scripting Example I provided in the overview post. Some of the major changes for Scripting API includes,

Changes for the ScriptEngine constructor
Now you need to use ScriptEngine instance’s Create Method instead of Session.Create(..) you had in earlier version of Roslyn.
The Execute method is now part of the Session, instead of Engine. So, instead of Engine’s Execute(code,session) in previous versions, you can directly call your Session’s Execute(code) method.

So, here is the updated code for the Scripting example I provided in the previous post. You could compare this with the previous example, and I’ve listed some of the changes below. Note that the change is only with in the ScriptingHost class

using System;
using System.Collections.Generic;
using System.Linq;
using Roslyn.Scripting.CSharp;
using Roslyn.Scripting;


namespace ScriptingRoslyn
{
    //Our Dog class so that we can train dogs later
    public class OurDog
    {
        private string _name = string.Empty;
        public OurDog(string name)
        {
            _name = name;
        }

        public string Name
        {
            get { return _name; }
        }

        public void Bite(OurDog other)
        {
            Console.WriteLine("{0} is biting the tail of {1}", _name, other.Name);
        }

        public void Walk()
        {
            Console.WriteLine("{0} is Walking", _name);
        }

        public void Eat()
        {
            Console.WriteLine("{0} is Eating", _name);
        }
    }



//Let us create a Host object, where we'll wrap our session and engine
//The methods in the host class are available directly to the environment
//Now you can create a ScriptEngine, and create a session out of the ScriptEngine

 public class ScriptingHost
    {
        private ScriptEngine engine;
        private Session session;

        //Methods in the Host object can be called directly from the 
        //environment
        public OurDog CreateDog(string name)
        {
            return new OurDog(name);
        }

        public ScriptingHost()
        {
            //Create the script engine
            //Script engine constructor parameters go changed
            engine=new ScriptEngine();

            //Let us use engine's Addreference for adding the required
            //assemblies
            new[]
             {
                    typeof (Console).Assembly,
                    typeof (ScriptingHost).Assembly,
                    typeof (IEnumerable<>).Assembly,
                    typeof (IQueryable).Assembly,
                    this.GetType().Assembly
             }.ToList().ForEach(asm => engine.AddReference(asm));

            new[]
                {
                   "System", "System.Linq", 
                   "System.Collections",
                   "System.Collections.Generic"
                }.ToList().ForEach(ns=>engine.ImportNamespace(ns));

            //Now, you need to create a session using engine's CreateSession method,
            //which can be seeded with a host object
            session = engine.CreateSession(this);
        }


        //Pass the code to the engine, nothing much here
        public object Execute(string code)
        {
            return session.Execute (code);
        }

        public T Execute<T>(string code)
        {
            return session.Execute<T>(code);
        }

    }

    //Main driver
    class Program
    {
        static void Main(string[] args)
        {
            var host = new ScriptingHost();
            Console.WriteLine("Hello Dog Trainer!! Type your code.\n\n");


            string codeLine;
            Console.Write(">");
            while ((codeLine = Console.ReadLine()) != "Exit();")
            {
                try
                {
                    //Execute the code
                    var res = host.Execute(codeLine);

                    //Write the result back to console
                    if (res != null)
                        Console.WriteLine(" = " + res.ToString());
                }
                catch (Exception e)
                {
                    Console.WriteLine(" !! " + e.Message);
                }

                Console.Write(">");
            }
        }
    }
}

And now, let us run our little scripting app. And try some LINQ queries as part of your script

Other API Changes

There have been some updates to the Roslyn APIs since the second CTP was released in June of 2012. Below is a summary of some of the most important changes, some of which are breaking. For example, In compiler APIs,

Instead of SyntaxTree.ParseCompilationUnit you can use ParseText or ParseFile instead.
Also SyntaxNode.GetText and SyntaxNode.GetFullText have been replaced with ToString and ToFullString respectively

You can see a full list of API changes here - Happy Hacking with the new Roslyn APIs, Enjoy C#

The problem with being passionate about technologies

noreply@blogger.com (Anoop Madhusudanan) — Sat, 15 Sep 2012 16:01:00 +0000

The title is a little bit misleading. There is nothing wrong with being passionate about technologies you love/like. In fact, I believe in being a passionate developer, and I appreciate having passionate people in my team and around me.

The real problem is – being subjective about something just because you are passionate about the same. Few quotes

Subjective

Subjective information is one person's opinion. In a newspaper, the editorial section is the place for subjectivity. It can be based on fact, but it is one person's interpretation of that fact. In this way, subjective information is also analytical.

Objective

Objective information reviews many points of view. It is intended to be unbiased. News reporters are supposed to be objective and report the facts of an event. Encyclopedias and other reference materials provide objective information.

Now, let us relate this to the developer’s life. Think about how you selected a specific framework or platform for your last assignment?

Whether your decisions were made using objective parameters? Like

POCs that confirms the merit of the framework/platform/approach
Team goals like cost, scope, quality
Valid references with in proper context

Or, you were driven by something subjective?

Your comfort level
Your own ego to prove what you suggested
The person who suggested a different approach was your wife’s ex boy friend

Subjectivity is bad because it’ll hurt others and yourself, and won’t let you focus on the real problems. Hence, especially with in a tech team, I think it is important to have a mutually agreed protocol to take architecture and design decisions objectively – and not subjectively.

I’ve observed that practicing two critical points should always help

Be open to explore suggestions from others - It is possible to have multiple ‘rights’ as two ways can lead to the same destination in the end.
If you have difference of opinions, be open, take that offline and have an in depth discussion focusing on the problem + solution.

So, I believe you can enjoy your coding better if you have an objective view point as I’ve myself fallen for my subjectivity multiple times. And a line of disclaimer

I wrote this post as an objective fact but is clearly a subjective opinion. lol.

5 points developers should know about WinRT/Windows 8

noreply@blogger.com (Anoop Madhusudanan) — Fri, 07 Sep 2012 11:49:00 +0000

Most of us already started developing for WinRT, so it make sense to have a better understanding of the run time. I am listing down few points with respect to WinRT, mainly from a developer’s perspective.

1 – WinRT is a new collection of COM objects, native to Windows

Here are some quick points about WinRT

WinRT is native, and all WinRT objects are unmanaged and use COM as the base.
WinRT objects implement IUnknown and ref counting.
WinRT objects wraps a new XAML UI system, along with Win32 APIs. It consumes tons of Win32 APIs (Do dumpbin on a WinRT library) . The new set of XAML libraries are purely native, don’t confuse them with Silverlight or WPF though the terminologies remain same.
As WinRT is COM and hence it is more closer to the Operating system, it is easier to write language bindings (Projections) for WinRT.
A projection is a way of expressing WinRT in each language. More about this below
Just in case you havn’t perceived it yet, WinRT world is totally different than the managed .NET world.
WinRT libraries are built ground up using these new set of WinRT objects, and are kept in the Windows* namespaces. Eg. Windows.UI, Windows.Media, Windows.Networking, Windows.Security, Windows.Devices etc.

2 – WinRT is not exactly your mama’s COM

You don’t need to work with the ~~crappy~~ old COM style, even while developing applications in C++. WinRT provides a higher level of abstraction, based on COM. Win RT implements multiple features on top of COM, including

A Subscriber/Publisher model implemented using .NET inspired Delegates and events. In ‘old’ COM, this was done using events/sinks
Parameterized interfaces or PInterfaces (some what equivalent to generics), and this can be projected if the language supports them.
WinRT components don’t implement IDispatch

3 – WinRT can be accessed from multiple languages/platforms

WinRT itself is language neutral. Also, WinRT has got a language neutral type system.

In some languages, you may even consume some WinRT types ‘as is’.
In some other languages (like C#), WinRT types may be mapped to equivalent language types. For example, in C#, WinRT’s IIterable<T> is mapped to IEnumerable<T> – where CLR will take care of the mapping.
Full list of WinRT <-> CLR mapped types table is here.

In short, you can ‘project’ WinRT to multiple languages. The language run time will take care of the Garbage collection implementation. All WinRT components implement IInspectible interface for projecting itself to other language environments.

4 – Though WinRT is unmanaged, it has got Meta Data

You might be thinking, if WinRT is so unmanaged, how we can call into WinRT from other environments, especially from the managed world without old techniques like P/Invoke?. In fact, Windows Runtime libraries are exposed using API metadata stored in .winmd files. You could find the winmd metadata corresponding to the WinRT libraries.

The format used for exposing metadata is the same as what is used by the .NET framework or Ecma-335 spec (Secret : WinMD files follow the same format of CLR assemblies though they don’t have any IL. Winmd files are just the definitions of the API. The implementation, as discussed, may be managed).
The underlying binary contract makes it easy for you to access the Windows Runtime APIs directly in the development language you choose.

As the metadata format is similar to the .NET format, you can open a .winmd file in ILDASM and explore, like this.

5 – WinRT API has got language bindings projections

As mentioned, a projection is a way of expressing WinRT in a specific language. You may also create WinRT components in one language, and may consume the same from another (because the metadata is available).

Presently, these are the projections available.

C++ Projections

Using the C++/CX (Component Extensions) which does compile time bindings and compiles the code to a native image. As WinRT is fully native, applications developed using C++ doesn’t need CLR/.NET to compile/run WinRT applications. C++/CX is a set of extensions from Microsoft for developing for WinRT (much like C++/CL was for developing CLR/.NET apps in C++).

C#/XAML

CLR is modified to support WinRT access from the managed world.

Now CLR can can map WinRT types when you use C# as the language.
When you create WinRT components in C# that can be used from other languages, you are further restricted to a minimal subset of C# (language features).

When you develop for WinRT in C#/XAML, you’ll notice multiple things.

As WinRT applications are sandboxed, you don’t have access to a lot of .NET libraries and types like File I/O. Only a minimal set of .NET APIs targeting the metro profile will be exposed
You don’t have access to the synchronous versions of a number of methods. You need to leverage the asynchronous versions in those cases.
When CLR does the mapping of WinRT types to CLR types, the WinRT type definitions are made private by the CLR. I may explain the actual mapping process in another post
You can access WinRT XAML library, or can use the WebView as the front end when you use C# for your metro style apps.

JavaScript Projections

Javascript projections are probably the most abstract and highest level projections for developing WinRT applications. How ever, you can’t create WinRT Components in Javascript. Also, you can’t use WinRT’s XAML library in/from JavaScript as of now. How ever, the advantage is if you are using Javascript, you could also leverage the HTML5 features for developing your applications. You can use the WinJS scripts and CSS files from Microsoft to provide the ‘metro-style’ look and feel.

That is about WinRT for a good start.

Up and Running with Meteor in a Linux VM in Windows Azure in 10 minutes

noreply@blogger.com (Anoop Madhusudanan) — Fri, 17 Aug 2012 08:59:00 +0000

I wanted a developer machine/server for doing some quick prototyping with Node and Meteor, and decided to setup one quickly in Azure. If you are wondering what is meteor, checkout this video from the meteor website.

Meteor provides a unique model that doesn’t require much plumbing as in ‘normal’ web applications, and you can write Javascript files that combine both server and client side logic, and can write to the database directly from the client side. Behind the scenes, Meteor will manage all the plumbing. Exciting? Here is a quick guided walk through to start with a Meteor server in a Linux Azure VM in 10 minutes.

1 – Setup the Linux Virtual Machine

To start with, Go to Windows Azure website http://windowsazure.com and sign up for the trial (There is a 90 day free trial for you to enjoy) if you don’t have an account. Head over to the management portal at https://manage.windowsazure.com, click New –> Virtual Machines –> From Gallery and choose OpenLogic CentOS 6.2.

Click next, and provide the details, including Virtual Machine name, user name and password so that Azure can setup the instance.

Also, configure the DNS name so that we’ve a URL to access the VM.

Click next and complete the VM creation process. Once your VM is provisioned, have a look at the End points, and you’ll find that there is a Secure Shell (SSH) end point for you to connect. Let us connect over SSH.

2 – Connecting over SSH using PuTTY

We’ll use PuTTY, a free implementation of SSH to connect to the VM. Go and download PuTTY from here – I prefer installing via the PuTTY Windows installer. Fire up your PuTTY executable, and connect to the Linux Virtual machine. Make sure to provide your host name instead.

Click Open, and in confirm the security alert and login via the Console by providing the username and password you provided while creating the Azure VM. In the PuTTY console, you can execute what ever Linux commands you need.

3 – Install Meteor

Now, installation of Meteor is dead simple. In the Putty Console, Just run

$ sudo curl https://install.meteor.com | /bin/sh

Once the installation is over, you can create a new project. I’m just creating a copy of the leaderboard example project. Cd to your leaderboard directory, and start the meteor server.

$ meteor create --example leaderboard
$ cd leaderboard
$ meteor

Now, we need to configure Azure end point rules to allow HTTP connections over port 3000. Just head over to Virtual Machines –> Meteor –> Endpoints section in the Azure management portal, and add a TCP end point for port 3000.

You are ready. Browse to your VM’s address http://meteor.cloudapp.net:3000 in my case, to see the leaderboard.

Explore the codebase for Leaderboard, and get amazed!!. Happy coding.

Note: There is a Windows Installer for trying out Meteor in your Windows machine, how ever it don’t support meteor update etc.

Bending Your Code Like Anders With C# Roslyn APIs - More About Syntax Trees

noreply@blogger.com (Anoop Madhusudanan) — Fri, 20 Jul 2012 13:34:00 +0000

In my previous post Introduction to C# Roslyn CTP, I gave a quick introduction about C# Roslyn CTP, and briefed how you could use C# as a Scripting Language using Roslyn. I also gave a quick introduction regarding parsing code using Roslyn APIs. Recommend you to read the same before starting this.

On a side note, you could also read few of my related C# vNext posts here.

Understanding C# Tasks and Parallel Extensions

C# 5.0 Async – A Simple Introduction

Using Mono for implementing C# Scripting

In this post, we’ll re-look at few Roslyn features, based on the June 2012 CTP release – so that you can start leveraging Roslyn to write your own build tasks and pre processors. Also, note that you can compile the Syntax Debugger Visualizer sample that comes with the Roslyn CTP – Find it in the Shared folder in the CTP installation. Open the SyntaxDebuggerVisualizer project and compile the libraries, and place it in your Documents\<VisualStudioFolder>\Visualizers so that you can visualize syntax trees during debugging.

Update: Roslyn CTP September 2012 now has got released, and there are some breaking changes. I suggest you read this post about the new September 2012 CTP.

Parsing Syntax Trees

So, let us start by parsing some code. Create a new Roslyn CTP Console project in Visual Studio, and try parsing this code. Note that in the new June 2012 CTP, Roslyn has added support for Query expressions, anonymous types, iterators, Indexers, switch statements etc. A Full list of features added since Oct 2011 CTP is available here.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Text;
using AForge.Genetic;
using Roslyn.Compilers;
using Roslyn.Compilers.CSharp;
using Roslyn.Scripting;
using Roslyn.Scripting.CSharp;

namespace Roslyn.Console
{   
    class Program
    {
        static void Main(string[] args)
        {

            string code=@"class SimpleClass { 
                                public void SimpleMethod()
                                    {
                                        var list = new List<string>();
                                        list.Add(""first"");
                                        list.Add(""second"");
                                        var result = from item in list
                                                     where item == ""first""
                                                     select item;
                                    }
                        }";


            var tree = SyntaxTree.ParseCompilationUnit(code);
        }

Now, put a break point near the closing bracket of our Main method, and try bringing up the Syntax Visualizer, assuming have the Visualizer libraries copied as above.

And check out the Syntax Tree formed by Roslyn. The most interesting part is how the LINQ Expressions are parsed. So, this should provide a useful way to load Query Expressions dynamically (for implementing dynamic filters etc), once full version is available.

Walking The Syntax Tree

Now, let us quickly explore how you can walk the syntax tree. You can simply inherit your own SyntaxWalker in the Roslyn API, that internally implements the Visitor pattern for visiting all nodes in the tree. Let us write a quick ConsoleDumpWalker that can dump the above syntax tree to a console, and a quick extension method so that we can use the walker to dump any syntax tree to console.

public static class SyntaxTreeExtensions
    {
        public static void Dump(this SyntaxTree tree)
        {
            var writer = new ConsoleDumpWalker();
            writer.Visit(tree.GetRoot());
        }

        class ConsoleDumpWalker : SyntaxWalker
        {
            public override void Visit(SyntaxNode node)
            {
                int padding = node.Ancestors().Count();
                //To identify leaf nodes vs nodes with children
                string prepend = node.ChildNodes().Count() > 0 ? "[-]" : "[.]";
                //Get the type of the node
                string line = new String(' ', padding) + prepend +
                                        " " + node.GetType().ToString();
                //Write the line
                System.Console.WriteLine(line);
                base.Visit(node);
            }

        }
    }

And now, you can try dumping your syntax tree with the above Dump extension method. For example, dumping the above code we parsed in step 1 should show the syntax tree we found earlier in the Debug syntax visualizer.

  var tree = SyntaxTree.ParseCompilationUnit(code);
  tree.Dump();

Modifying the Syntax Tree

Modifying Syntax Trees are equally easy. You can implement your own syntax re-writers, by inheriting from the SyntaxRewriter class. Here is a pretty naïve SyntaxRewriter, that appends an ‘I’ to the beginning of all interfaces that doesn’t start with an I in their name. In an actual scenario, you should also change the related implementations, but this is just for an example. So, here is our InterfaceRenameRewriter

//Our rewriter
public class InterfaceRenameRewriter : SyntaxRewriter
    {

        public override SyntaxToken VisitToken(SyntaxToken token)
        {
            //If the token is an identifier name, and it's 
           //parent is an interface declaration

            if (token.Kind == SyntaxKind.IdentifierToken && 
                   token.Parent.Kind==SyntaxKind.InterfaceDeclaration)
            {
              //If the name doesn't start with I - bluntly fix it. 
               if (!token.GetText().StartsWith("I"))
                    {
                        return Syntax.Identifier("I" + token.GetText());
                    }
            }

            return base.VisitToken(token);
        }

    }

And you can test our InterfaceRenameRewriter on some sample code.

            string code = @"interface SomeInterface { 
                                //Some Simple Method
                                public void SomeMethod();
                        }";


            var root = SyntaxTree.ParseCompilationUnit(code).GetRoot();
            var commentRewriter = new InterfaceRenameRewriter();
            var newRoot = commentRewriter.Visit(root);

And if you inspect newRoot, you’ll find that the interface name got renamed as intended. Here we go.

You can experiment with more overrides available in the SyntaxRewriter, as you understood how to modify syntax trees. Another way to modify syntax trees is directly replacing an old node in the root with a new node, but that is quite simple.

So, in this post we explored a bit about Roslyn Syntax Trees, and we saw how to start bending your code to write your own build tasks and pre-processors- Oh yes, all of us will take a little bit of time and practice to really bend it like Anders and Eric – but you just kicked the ball. Happy coding. Checkout my other C# posts as well

Amazedsaint's Tech Journal

May be this is the best time for Microsoft to Open Source the .NET Framework

Hack Raspberry Pi – How To Build Apps In C#, WinForms and ASP.NET Using Mono In Pi

Step 1: What is Raspberry Pi?

Step 2: Setting up your Development Environment

Step 3: Booting the Pie And Installing Mono

Step 4: Writing C#

Step 5: Write And Compile Your Code – A Windows Forms app

Step 6: Installing The XSP Web Server For Some ASP.NET Love

Conclusion

BIG DATA for .NET Devs: HDInsight, Writing Hadoop Map Reduce Jobs In C# And Querying Results Back Using LINQ

Preface

Step 1: Setting up your instance locally in your Windows

Step 2: Install the Map Reduce package via Nuget

Step 3: Writing your Mapper and Reducer

Step 4: Writing your Namespace Counter Job

Step 5: Submitting the job

Step 6: Executing the job

Step 7: Loading data from HDFS to Hive

Reflection API Changes in .NET 4.5 Applications and Fun with Custom Reflection Context

Azure Hadoop HDInsight Tools – Wrote A VS Add In For LINQ To Hive Model Generation and Hive SQL Queries

About That ‘Feelings’ In Software Industry

AutoCommand For MVVM – More tricks With Lambdas and CallerMemberName

A Quick introduction to Hadoop Hive on Azure and Querying Hive using LINQ in C#

Book Reviewed - Kinect for Windows SDK Programming Guide By Abhijit Jana

Lambda patterns in C#?

Convention Based Strategy Pattern *_*

Portable Library and WinRT support for ElasticObject

Top posts from 2012 – Roundup Post

A quick note on Closing lambda loop variables in C# 5.0 - Breaking Changes in C# 5.0 compiler

‘HTML5 vs. Hybrid vs. Native Dilemma’ When You Build Enterprise Mobile Applications - The Bigger Picture

The Bigger Picture

Hybrid vs Native

And More

Changing Times For Web Developers – 6 Tips You Should Read To Survive

1 – Learn to write better JavaScript and CSS

2 – Familiarize yourself with a Responsive Framework

3 – Learn the most useful JavaScript MVC frameworks

4 – Understand REST and HTTP

5 – Understand HTML5 Beyond the Buzzword

6 – Optimize

Meet Ms. Roslyn – Article in DNC Magazine

Why I’m truly excited about Windows 8 – It is all about connecting the dots

It is all about Connecting the dots

A number of devices to choose from

The productivity factor

Type Script Language Features – Classes, Inheritance & Overriding

Classes in Type Script

Parameter property declaration

Inheritance & Overriding

‘super’ Keyword

Microsoft TypeScript : A quick introduction and A Love Affair Begins here.

A Quick Hello World in TypeScript

Function Types

Object Types

A Bit more about Types in Typescript

Conclusion

Introducing SignalWire – Magical Plumbing with your Data Store + C# and LINQ in your HTML pages

How To Start

Server – Data Context and Hub

Client - Initializing and Issuing Queries

Other Wire Methods

Permissions

What's More

Roslyn September CTP 2012 Overview – API Changes, Using Modified APIs for C# Script Execution, Embedding C# as a scripting language

What’s Exciting In September CTP (CTP3) release

Scripting API Changes

Other API Changes

The problem with being passionate about technologies

5 points developers should know about WinRT/Windows 8

1 – WinRT is a new collection of COM objects, native to Windows

2 – WinRT is not exactly your mama’s COM

3 – WinRT can be accessed from multiple languages/platforms

4 – Though WinRT is unmanaged, it has got Meta Data

5 – WinRT API has got language bindings projections

Up and Running with Meteor in a Linux VM in Windows Azure in 10 minutes

Bending Your Code Like Anders With C# Roslyn APIs - More About Syntax Trees

Parsing Syntax Trees

Walking The Syntax Tree

Modifying the Syntax Tree

Convention Based Strategy Pattern _