Getting into my skin – SOA with Biztalk

I will be talking today at BDOTNET on how we can drive our Organization’s SOA efforts using Biztalk. When I started with Biztalk, I was struggling to apply it into my solutions (when to when not to – Biztalk?). I had heard of SOA but wasn’t quite sure what it stood for (was it just a web service?). Apart from that, Session will showcase few down to earth samples – why Biztalk makes sense for Enterprise SOA efforts. If you feel the above is what you are struggling with or need clarity on, be sure to occupy seats by 11:00 A.M. I will make best of my efforts to provide value for your time and petrol .

MVC vs. MVP vs. MVVM

An important FAQ. The answer actually depends on where the person is coming from. MVC is a fundamental pattern which has been tweaked quite a bit to fit into various platforms. For instance if you had asked anybody how to implement an MVC in ASP.NET (prior to release of ASP.NET MVC framework) you would get very different answers. So let’s start with basic. The common motivation behind all 3 is separation of concerns, cutting flab from UI (good for UI designers), swapping UIs (for instance windows to web), make UI easy for Unit Testing, etc. Have a look at the below diagram, I have taken it from CAB documentation.

MVC: Three components – View (your UI), Model (your business entities / data – that view is displaying) & Controller (contains the logic that alters the model depending on the action triggered by UI, typically implementing a Use Case). It’s widely known that MVC is a compound pattern (View and Controller have Strategy implementation, View itself can be a Composite implementation & View and Model are synched through Observer). In this case Controller doesn’t know anything about View, and the idea is that a View can switch Controllers (for instance depending upon who has logged to the system) & a single controller can be used by multiple Views. View subscribes to the changes done to the model & hence both are sync from the data perspective. One of the disadvantages of MVC is that it’s difficult to unit test. Controller manipulates the data but how about asserting those changes from a view perspective. For instance on click of a button you raise an event to controller, and controller modifies the value in model. This value modification changes the font size / color in View. Unit testing this scenario is slightly difficult in MVC.

MVP: Again three components. But dependencies change (look at arrows in the diagram). Over here we replace Controller with Presenter (one which presents the changes done in model back to view). The main difference between both is that Presenter refers back to the view while Controller doesn’t. Normal pattern found here is to create an abstraction of the View (in terms of properties / events) & Presenter refers to it. This makes the mocking of View much easier (also model sync is with presenter) & hence the Unit Testing aspect. Presenter here hence takes the responsibility of not only manipulating model but also updating the view. Of course the implementations of MVP differ in real world in terms of how much thin the view is, some prefer keeping basic logic still inside view & taking complex logic in presenter, while others prefer keeping the entire logic in Presenter. Martin fowler describes 2 variations on MVP on these lines namely – Supervising Controller & Passive View described below

(A Passive View handles this by reducing the behavior of the UI components to the absolute minimum by using a controller that not just handles responses to user events, but also does all the updating of the view. This allows testing to be focused on the controller with little risk of problems in the view.

Supervising Controller uses a controller both to handle input response but also to manipulate the view to handle more complex view logic. It leaves simple view behavior to the declarative system, intervening only when effects are needed that are beyond what can be achieved declaratively.)

MVVM: Model–View-ViewModel talks of creating a new model (in addition to your domain model). This model normally adds additonal properties from the prespective of View (as we understand that View has controls in addition to data which it’s displaying). For instance if View had a property IsChecked and Presenter was setting in classic MVP, in MVVM Presenter will have that IsChecked Property which View will sync up with (doesn’t it look like Startegy pattern has been replaced with Observer?). So now a Presenter becomes more like a combo of – View Properties & Model properties which would be synchronized with View. So why not rename Presenter to ViewModel? Do that and you get MVVM. MVVM is attractive for platforms which support bi-directional binding with less effort. Also a minor tradeoff is ViewModel unlike Presenter can stand on its own (Presenter normally requires a View’s interface). Martin fowler describes similar pattern called Presentation Model & Josh Smith captures MVVM implementation for WPF / Silverlight in this article.

ASP.NET MVC: So what has MVC got to do with ASP.NET MVC? First, Web works on a different model. Here, user interacts with HTML in browser and send a request back to the server for processing (for client side Ajax you might go just for data). As the interaction is normally stateless, when the request comes back to the server we need to recreate our View, load the model back & manipulate both of them as required. There are 2 variations on how handle this recreation – Page Controller & Front Controller. Make Page the decision maker – in this widely implemented pattern HTTP request is specific to physical page on server (.aspx for instance) & page in turn creates itself (builds the view from postback data) decides what model it needs and triggers the manipulation (events in codebehind file) it requires. As you see here the distinction between View & Controller becomes blur & is little difficult to separate. This where ASP.NET MVC comes in which behaves like a Front Controller – where Controller is the decision maker. Here all HTTP requests are mapped to methods on the Controller Class. Controller class recreates the model & view as required and does the manipulations. This makes unit testing easier as we can directly instantiate the front controller class & invoke methods on it to perform the assertions.

I can add code snippets to above explanations if you feel they would help you understand things better. I will look forward to your comments .

Loading 2 Versions of the same .NET Assembly

This can be an interview question . Let’s say I have a class

public class Class1 //1.0.0.0 – in C:
{
public string SayHello()
{
return “Hello World”;
}
}

and I version it to 2.0.0.0

public class Class1 // in C:\2 folder
{
public string SayHello()
{
return “Hello India”;
}
}

So you have 2 assemblies. Now, write a program in .NET to print Hello World & Hello India. Simple – use Assembly.LoadFrom (LoadFrom takes a path while Load goes through Assembly Resolver & Loader).

class Program
{
static void Main(string[] args)
{
Assembly assm = Assembly.LoadFrom(@”C:\ClassLibrary1.dll”);
Type[] types = assm.GetTypes();
foreach (var t in types)
{
Object obj = assm.CreateInstance(t.FullName);
Console.WriteLine(t.GetMethod(“SayHello”).Invoke(obj, null));
}

Assembly assm2 = Assembly.LoadFrom(@”C:\2\ClassLibrary1.dll”);
Type[] types2 = assm2.GetTypes();
foreach (var t in types2)
{
Object obj = assm2.CreateInstance(t.FullName);

Console.WriteLine(t.GetMethod(“SayHello”).Invoke(obj, null));
}
}
}

But to your suprise the output remains – “Hello World” & “Hello World”. If you take the second block first, output will change to “Hello India” & “Hello India”. Neither of them is what we expected. Conclusion – It’s not possible to load 2 assemblies by same name inside a single AppDomain. So you will have to create a seperate AppDomain & load the second version of assembly into it as shown below:

class Program
{
static void Main(string[] args)
{
Assembly assm = Assembly.LoadFrom(@”C:\ClassLibrary1.dll”);
Type[] types = assm.GetTypes();
foreach (var t in types)
{
Object obj = assm.CreateInstance(t.FullName);
Console.WriteLine(t.GetMethod(“SayHello”).Invoke(obj, null));
}
AppDomain app = AppDomain.CreateDomain(“Child”, AppDomain.CurrentDomain.Evidence, new AppDomainSetup { ApplicationBase = @”C:\2″ });
Assembly assm2 = app.Load(@”ClassLibrary1″);
Type[] types2 = assm2.GetTypes();
foreach (var t in types2)
{
Object obj = assm2.CreateInstance(t.FullName);

Console.WriteLine(t.GetMethod(“SayHello”).Invoke(obj, null));
}
}
}

Do you have any better ways?

Tower Servers vs. Rack Servers vs. Blade Servers

Continuing my hardware series let me try to put the basic differences between above three.

Tower Servers are the normal boxes (in appearance) you would have seen in Visio Diagrams. Of course they are very powerful & have bundled software tools to manage them. The problem with Tower Severs is the space they occupy, management personnel they require, and cost of operating them (power, network, etc.).

Rack Servers are servers mounted inside a Rack (something like we normally use to manage our letters, office files, etc.) Major Racks available out there adhere to an IEEE standard and are measured in rack units or “U’s” (each U is 19” wide and 1.75” tall). So a rack server size is typically in multiplication of these “U’s”. Motivation here is to scale vertically than horizontally with more compact physical servers. In addition to this, there are many other electronic devices which adhere to this IEEE standard for instance – Rack Consoles, SAN devices, Power Backup devices, etc. Advantage being that you can fix them into rack as well along with your servers. Not to mention that the hardware vendors (Dell, HP, IBM, etc.) provide additional software tools that help you effectively manage these servers and in some cases the supported devices also.

Blade Servers are an additional level of innovation on top of Rack Servers. Blade Servers are typically placed inside a blade enclosure, and together they form a blade system. A Blade system normally meets the IEEE standard of Rack Units, which means that the entire Blade system can be placed inside the rack along with other electronic equipments. The benefits of blade enclosure includes hot plugging (normally blade servers have a handle attached to them, for transferring them in and out of the blade enclosure – it’s an easy way of identifying them) and stripped modular design (e.g. shared network ports, power connections, switches, etc.). For instance the hardware we ordered allows us to pack 16 blade servers inside a 10U space. I remember meeting an Oracle Consultant few months back where he was touting about a server with no disk. Such scenarios are possible (and are cheaper) by coupling a blade system and SAN storage. All these boils down to further space reduction, cost savings (power, administration staff) & easy management. Bundle this with Virtualization and you have a very powerful infrastructure at your disposal.

So any guesses as to what the next generation of servers would be ?

Passing Optional & Unordered Parameters via ODP.NET – PLS-00306

Times change. Recently I was interacting with a team that was using ODP.NET. And they had this stored procedure written in SQL server which they were moving to Oracle DB. They had some challenges in porting their data access code to support Oracle. One of them was – ODP.NET requires all parameters (even if they have default values) to be passed to the Stored Procedure and also expects them in the same order. But with SqlClient the same is not required. Solution to this is use BindByName property of OracleCommand class. Let me elaborate through a small sample code for better understanding:

Consider the following dummy procedure using the above Dummy Table
CREATE PROCEDURE [dbo].[DummyProc]
@Age As Int,
@Name As varchar(50) = ‘AA’ –default value
AS
BEGIN
SET NOCOUNT ON;
DECLARE @noOfRows as INT

SELECT * from Dummy d where d.Age = @Age AND d.Name = @Name

SELECT @noofrows = @@rowcount –tSql is not case sensitive
RETURN @noofrows
END
Now the C# code to pass parameters to this would be:

SqlConnection conn = new SqlConnection(@”ConnString”);
conn.Open();
SqlCommand command = conn.CreateCommand();
command.CommandType = System.Data.CommandType.StoredProcedure;
command.CommandText = “DummyProc”;
command.Parameters.Add(new SqlParameter(“@Age”, 2)); //Order doesn’t matter
//command.Parameters.Add(new SqlParameter(“@Name”, “AA”)); – This is not required
SqlParameter paramReturnCode = command.CreateParameter();
paramReturnCode.ParameterName = “ReturnCode”;
paramReturnCode.DbType = DbType.Int32;
paramReturnCode.Direction = ParameterDirection.ReturnValue;
command.Parameters.Add(paramReturnCode);
command.ExecuteNonQuery();
Console.WriteLine(command.Parameters[@"ReturnCode"].Value);
conn.Close();

//Output
1

Pretty simple. Let’s move the above to oracle now & access it from ODP.NET. First let’s create a stored procedure in Oracle.

create or replace
PROCEDURE DUMMYPROC
( p_Age IN NUMBER
, p_Name IN VARCHAR2 DEFAULT ‘AA’
, p_NoOfRows OUT NUMBER
) AS
BEGIN
select count(*) into p_noofrows from dummy d where d.age = p_Age AND d.name = p_name;
–N.B. In above ‘into’ is required, for select returning a recordset you need a RefCursor
END DUMMYPROC;

Now let’s write some code using ODP.NET (Oracle.DataAccess.dll)

OracleConnection conn = new OracleConnection(@”ConnString”);
conn.Open();
OracleCommand command = conn.CreateCommand();
command.CommandType = System.Data.CommandType.StoredProcedure;
command.CommandText = “DummyProc”;
//command.BindByName = true;
command.Parameters.Add(new OracleParameter(“p_Age”, 2));
//command.Parameters.Add(new OracleParameter(“p_Name”, “AA”)); // This is not required
OracleParameter paramReturnCode = command.CreateParameter();
paramReturnCode.ParameterName = “p_NoOfRows”;
paramReturnCode.OracleDbType = OracleDbType.Int32;
paramReturnCode.Direction = ParameterDirection.Output;
command.Parameters.Add(paramReturnCode);
command.ExecuteNonQuery();
Console.WriteLine(command.Parameters[@"p_NoOfRows"].Value);
conn.Close();

The above code on execution throws an error – PLS-00306: wrong number or types of arguments in call to ‘DUMMYPROC’. The issue here is oracle expects all parameters to be passed in same order for faster execution. But as it turns out that it’s not always the case. Run the same Oracle code above but uncomment line no. 7 – command.BindByName = true

And here you are with the expected output.
//Output
1

Hope this helps .

I am back :)

What a way to celebrate a year of blogging!!! Yesterday not only marked a year of this blog (started in June 2008) but I also got my MVP status renewed into a more fitting category of – “Connected Systems Developer”. I wanted to write a detailed blog post about this, explaning the ins & outs of the MVP program but then thought otherwise. As usual, I owe the award to my family (for allowing me to stay away whenever it was required), friends @ Microsoft for providing opportunities to contribute & knowledge to share, and my MVP lead Abhishek. And last but not the least, you guys who make communities such a passionate place. A humble thank you to everyone .

Types of Virtualizations – Server Virtualization vs. Desktop Virtualization vs. Application Virtualization

Praveen convinced me yesterday to have a look at Virtualization. I am jotting down few thoughts on the same. The word “Virtual” means “Existing in essence though not in fact”. Below I have outlined the basics of common Virtualization techniques out there, hope you find them useful (though it’s mainly from Microsoft Perspective).

Server Virtualization: I guess this is the most used one. Every time you want a new server you have to go your IT department, and they will put you in queue – either due to budgets, servers occupied, time to setup, etc. Challenge for IT department is most of the allocated servers are not fully used, and nobody is willing to share their Server with others. This is where Server Virtualization comes in. Server Virtualization gives you the power of creating Virtual machines which in turn can share the physical resources of the underlying Server (adding saving of power, space, coolant and professionals). Every virtual machine runs in isolation and has its own OS and applications as required. Technology that enables this is called Hypervisor which sits in between the underlying hardware & virtual machines (for instance Hyper-V available for Windows Server 2008 64 bit editions). Apart from virtualzing the underlying hardware for Virtual Machines, Hypervisor also supports live migration (only with 2008 R2) of Virtual machines (in case there is a failure / up gradation of underlying host hardware) which results in higher up times, Load balancing (moving workloads to less utilized host Server) and power management (turn of machines which have no workloads). Understanding Server Virtualization is necessary for anybody to understand about how Azure (Microsoft cloud) operates.

(N.B. Microsoft Hyper-V Server 2008 which a variant of “Windows 2008 Core” comes with CLI only interface, helping you getting speed up with your Server Virtualization efforts. Also you can migrate your .VHD created by Virtual Server to use Hyper-V).

So will my existing hardware suffice? It can but it may not scale enough. Lot of hardware innovation is currently going on to leverage on Server Virtualization. For instance, Intel VT-x processors ensure better scalability, performance & reliability for Server Virtualization efforts.

Desktop Virtualization: This consists of 2 parts – Client hosted desktops & Server hosted desktops. Client hosted desktops help creating a virtual environment for running legacy applications (for e.g. you have an application running only on Windows XP but your current OS happens to be Windows 7). The way we normally get this working is by using Virtual PC or Windows Virtual PC (bundled with Windows 7). Microsoft Enterprise Desktop Virtualization (MED-V) makes management of these Virtual PCs (vmc / vhd) a breeze. Coming to Server hosted desktops, here the client OS, Applications & Data are kept on Severs in data centers benefits being better utilization of hardware, easy maintenance& better accessibility (for instance you can access the desktops from your home). The technology which enables this is called Virtual Desktop Infrastructure (VDI) leveraging protocols like Remote Desktop. The technology is still evolving so it’s recommended you do a thorough check on it before proceeding.

Application Virtualization: Here the Applications are virtual (they are never installed physically on boxes either due to conflicts with it’s previous version / other applications or for security reasons). Only thing required for installation on client machine is App-V client. Software is either streamed or cached locally on demand and then executed (sandbox execution). The Microsoft product which enables this magic is called App-V (previously known as SoftGrid). Other benefits of App-V include centralized management, easy scalability, easy availability, easy deployment, etc. There is also another technique for Application Virtualization supported by few vendors – Presentation Virtualization (Screen Scraping). Here the screen travels all the way to your terminal while application is running on server & your input gestures are transferred back (we had proposed this to one of our clients who was insisting on a web based application while we had a windows application).

Other Virtualization Products: XenApp, XenServer, XenDesktop – Citrix; VMware, Vmotion – VMware

I would look forward to read your thoughts on above .

Tech Ed On Road Demos & PPTs – Azure Services

Dear All, as promised here is the complete pack of slides & demos. It is really difficult to cover all Azure Services with Demos in just 45 minutes and that too with a machine reboot it’s a mission impossible. But thanks to Jani who kept going despite the issues, allowing me to bring things up again. By the way am I sort of impressed by the theme of demos we came up with – a paper less feedback for an event, guess that’s the way to go. If you have any doubts on demos or presentation (though we took care that they are no more than few lines each), feel free to put it across.

A special thanks to platinum sponsors of the event – Telerik and Infragistics without whom event wouldn’t have been possible.

Last but the not the least – Jai Ho – Tata Indicom . Love you all.

Entering Cloud with Tech Ed On Road

I will be doing a session on “Azure Services Platform” at this upcoming – Tech Ed On Road. It’s a joint event organized by BDOTNET & BITPRO user groups. Cloud for me is the most promising upcoming technology & recently I have been investing lot of my time in it. My co-speaker for the session is Janakiram (I would be surpised if you are following Azure and haven’t heard about him), who is about to hit a silver jubilee on Azure sessions. I have started enjoying combo talks after the one I did with Ramnish back at Tech Ed, I am quite hopeful that this too would be worth your time & petrol. Registrations are already closed but if I can still try helping out (after all I need to give some benefits to my readers , though no promises are implied). Do drop a line to me on the same, and I will try my best. I will also post the samples & presentation slides here after the event. Looking forward to meet you all. Keep Rocking.

RAID 0 vs. RAID 1 vs. RAID 4 vs. RAID 5 vs. RAID 10

My company had ordered some hardware recently. As usual, the buying process brought in lot of insights which I thought of sharing with you guys. I will cover them all in parts, starting with basics. First let’s see a fundamental concept called RAID which becomes critical when you start planning your storage.

RAID (Redundant Array of Independent Disks) – This technology is mainly used for hard disks to provide protection against hard drive failures and also to improvise performance (of course you can select either of failure protection / performance). RAID also gives an implicit way to scale your disks (after all it’s an Array). RAID builds on 2 primary concepts – Striping (storing data across multiple disks sectors of multiple drives so that disk head can read more data in a single move) and Mirroring(replication of drives). RAID requires minimum of 2 disks & can have maximum of 32 disks. It’s also important to note here that RAID controllers typically abstract out the striping & mirroring details giving end user a feel of only a single disk available at disposal. Below are some of the popular RAID configurations out there:

RAID 0 – Striping
Pros: Better performance – data replicated across drives, no storage overhead as drives are utilized 100%
Cons: Possibility of losing entire data on failure of a single disk
Minimum Disks Required – 2

RAID 1 – Mirroring
Pros – Guard against disk failure as data is replicated across disk drives
Cons – Replication creates storage overhead as the same data is copied across drives
Minimum Disks Required – 2

RAID 4 – A Mirroring variation. It actually uses the concept of ‘Parity’ (based on XOR operation – Sum of all bits across drives – if sum is even parity set to 0 else parity set to 1) to retrive data in case of a disk failure, which reduces storage overhead – an issue with RAID 1.
Pros – Reduced storage overhead (actually we need only a single disk here to store parity). E.g. if you have 3 disks, parity can be stored on 3rd. So your overhead is only 33% in terms of storage.
Cons – Still suffers from a performance prespective
Minimum Disks Required – 3 (anyways 2 doesn’t make sense and the more no. of disks you have lesser would be your storage overhead)

RAID 5 – Striped Data & Striped Parity – most widely used. Taking RAID 4 to next level by striping the parity (parity gets stored across disks instead of getting stored on single disk) and also striping data (that anyways doesn’t matter as far as parity is concerned)
Pros – Good Performance, Good failure protection
Cons – Not as good when your requirement is only performance or only failure protection (parity doesn’t come for free).
Minimum Disks Required – 3

RAID 10 (1 + 0) – Combination of Stripe & Mirror with no parity. You stripe the data across drives & mirror the entire set of drives.
Pros: Best in terms of performance & guards against potential failures.
Cons: Costly in terms of storage overhead
Minimum Disks Required – 4 (and for > 4 you must have even number of disks)

There are few other RAID levels which I would leave for the reader to digg into, as they are comparatively not that widely used. I will continue exploring hardware aspects further in next thread.