Super.NET Blog, Dawg

Words on the brave path towards a ubiquitous .NET client model.

Developers Win! is now Super.NET. Learn More

Why an HTML5-Compliant .NET is Important

TL;DR: Vote!

Exploring an HTML5-Compliant .NET

I recently got a good question on the .NET Foundation Forums in regard to why I (and nearly 5,200 other votes as of this writing) feel so strongly about having an HTML5-compliant .NET (that is, a .NET runtime that runs within a browser process).  I attempted to answer the question here and here.  However, another point has emerged that has been nagging at me that I wanted to share.  So, rather than pollute the great thread there (seriously, do yourself a favor and read the entire thing) with yet another post, I decided to make a quick post here instead.  Besides, I haven’t really posted here in a while and it is probably way past time to dust this thing off.

Creating an Ubiquitous Application: Pre-Xamarin

Let’s say we want to create an application with maximum market reach, meaning we want it to reach as many devices as possible in today’s current marketplace.  At a minimum we will need:

  • Server (to host our APIs, services, and backend infrastructure code).
  • iOS native application
  • Droid native application
  • Windows native application
  • Website (really a web “application”)

Each of these require a codebase to operate.  Before the acquisition of Xamarin, to do this in .NET, you would use (with languages):

  • Server: .NET/C# (Serves 100% of the market of modern devices)
  • iOS: Objective-C (Roughly 50% of the market)
  • Droid: Java (Roughly 50% of the market)
  • Windows: .NET/C# (Roughly 30% of the market)
  • Web Application: JavaScript (100% of the market)

Let’s say for an entire year, each codebase within your solution would cost $100k — per language used.  This cost consideration is very rough estimate from a small business perspective and includes:

  1. Acquiring the developer/resource necessary to code in that particular language
  2. The cost to develop the code
  3. The cost to maintain the code after it has been developed

Again this is per language as each language is incompatible and cannot be shared between the other.  Using the setup above, we can combine the efforts in the Server and Windows as they both share the same language (.NET/C#) and can therefore share code between the two.

So, our TCO breakdown would now look like (pivoting on technology used):

  • .NET/C#: ~$100k
    • Server
    • Windows native application
  • Objective-C: ~$100k
    • iOS native application
  • Java: ~$100k
    • Droid native application
  • JavaScript: ~$100k
    • Web application

Estimated Total Annual Cost of Ownership: ~$400k

Post-Xamarin Acquisition

The above of course does not consider the Xamarin acquisition from last year.  Microsoft did the right thing here, not just from the technology perspective, but from the business and cost perspective.  Now our TCO breakdown looks like this when considering Xamarin in a .NET solution:

  • .NET/C#: ~$100k
    • Server
    • iOS application (Xamarin)
    • Droid (Xamarin)
    • Windows native application (UWP)
  • JavaScript: ~$100k
    • Web application

Estimated Total Annual Cost of Ownership: ~$200k

Getting better, right?  Well, it is.  We have effectively halved our TCO.  Good work, everybody, pat yourselves on the back!  However, we can do better, right?  As a savvy small business owner, we have to consider all possible options and especially those that can save us even more money.  If we now take the perspective of said business owner who is technology-agnostic and not tied to a particular stack (read: has not drank the MSFT koolaid), we can now consider maximizing our investment with any technology available that also attains our desired market reach.  This means comparing costs between .NET (above) and also JavaScript.  So, let’s compare the above with a JavaScript-based solution:

  • JavaScript: ~$100k
    • Server (NodeJS)
    • iOS application (Cordova / NativeScript / React Native)
    • Droid application (Cordova / NativeScript / React Native)
    • Windows application (Cordova / NativeScript / React Native/ or even Windows Hosted Webapps)
    • Web application (JavaScript’s/HTML5’s native environment, baby!)

Estimated Total Annual Cost of Ownership: ~$100k (!)

It’s Just Business

So again, each of these $100k blocks are rough estimates, but you can now see we are dealing with a roughly $200k .NET/JavaScript Annual TCO vs. $100k JavaScript Annual TCO.  As a technology-agnostic small business owner who has a, say, $250k annual budget, which approach makes the most sense to you?

Good at Bizness

Good at Bizness