Breaking down the admittedly messy math shows that Google didn’t exactly lose nearly $10 billion on the deal. Here are some back of the envelope calculations.

When Google bought Motorola, the hardware maker had about $3 billion in cash on hand and nearly $1 billion in tax credits. So that brings the original deal’s effective price down to about $8.5 billion.

Then, Google sold Motorola’s set-top box business to Arris for nearly $2.4 billion. That lowers the effective price to roughly $6.1 billion.

Now, Google is selling Motorola Mobility — primarily the handset business, along with a few patents — for $2.9 billion. So we’re at about $3.2 billion.

It’s worth noting a few more things. In a regulatory filing in 2012, Google disclosed that it valued Motorola’s overall “patents and developed technology” at about $5.5 billion.

Google likely offered to get out of hardware if Samsung cross-licensed their patents and stopped pseudo-forking Android. Given Samsung’s dominant position in the Android ecosystem, the Motorola bargaining chip very well may have been worth several billion dollars.

It's the enterprise, stupid

[Motorola has] focused on building a smaller number of great (and great value) smartphones that consumers love. Both the Moto G and the Moto X are doing really well, and I’m very excited about the smartphone lineup for 2014.

Labels: business, Google

Labels: hardware, imac

But, if you draw your DDD bounded contexts well, you’ll find you need a lot less Big Bad Frameworks to get things done.

You give the ORM a query, it builds SQL out of it, then it constructs a DynamicMethod to materialize data coming back from SQL into your business objects. I am not privy to the exact implementation, it may be including more or less work in these dynamic methods.

This implementation is an abstraction, and it leaks. It leaks performance, you give up some control over the queries you can run and have to deal with a LEFT JOIN syntax that is so crazy it can make grown men cry.

Over the years, I've seen several object-relational-mappers (ORMs) come along for .NET and always ultimately end up being somewhat disappointed with the end result. I remember seeing a preview of LINQ-to-SQL being absolutely blown away by the speed and ease with which you could generate code which would manage the movement of data between your relational database and your business object model. And all without having to hand-roll any SQL! A little later, it was Entity Framework which, at the time at least, seemed to be like LINQ-to-SQL but even better!

However, the time eventually came when I had to use some of these technologies in real-world development projects and it was then that some of their limitations became apparent. From cumbersome XML definition files to sub-optimal performance, I have spent so much time implementing 'fixes' and 'workarounds' to try and shoe-horn a framework into a project's architecture and get it to perform the way I want, that now (unless it is a very simple 1-tier application that needs to be developed rapidly), I prefer to go back to using the stalwart ADO.NET classes of yesteryear, as they offer the flexibility and control over my data access layer that I often find is taken away from me when using some of these ORMs.

Labels: nhibernate

Recently, I happened to see my Google Profile which had a section “Contributor To” and under which, was a link with “Buzz(current)”. When I clicked on the link, my browser downloaded a PDF which had all my buzz conversations! Oops, I did not expect that, even-though I was not a active Buzz contributor!

Labels: archive, Google

LINQ is used to query data, T-SQL queries are not supported

Labels: c#, DataTableWP8, mono, SqlDbSharp, windows phone, xamarin

Labels: apple, imac

System.Data is not available for use in a Metro-style application.

Bob Tabor (LearnVisualStudio.NET) and Clint Rutkas (Microsoft/Channel9) team up to deliver this 11 hour Windows Phone 8 Development for Absolute Beginners series! Not only will you learn the absolute basics of installing and working with Visual Studio Express 2012 for Windows Phone and the Emulator, but you'll also learn XAML layout and events, how to utilize many of the Phone's built in features and additional open-source libraries.

Labels: c#, console, development, windows phone

An interface type is a specification of a protocol, potentially supported by many object types. Use base classes instead of interfaces whenever possible. From a versioning perspective, classes are more flexible than interfaces. With a class, you can ship Version 1.0 and then in Version 2.0 add a new method to the class. As long as the method is not abstract, any existing derived classes continue to function unchanged.

Labels: coding, style

Once the Dev Tools are undocked, press Control Shift I (on Mac press Alt Command I), that new window that just popped up is the inspector for the first Dev Tools window!

Labels: chrome, firebug

Have you ever noticed that out of the box NHibernate’s DateTime type will truncate/ignore your milliseconds for DateTime fields?

Dion Almaer, who had worked on developer tools at Mozilla earlier in his career, noted the significance of [the lead Firebug programmer in 2011, John J.] Barton's new job in a blog post today.

"Firebug used to be the way you debugged your sites, but that is changed," Almaer said. "It is too early to claim that Firebug is zombied, but all eyes will be on that...especially as we see other browser tools continue to blossom."

Labels: chrome, firebug, firefox

Labels: tfs, Trello

using System;

namespace ConsolePlay
{
    public class DelegateTester
    {
        public delegate void EventHandler(string strIn);
        public void raiseEvent (int intInput, EventHandler eventHandler)
        {
            if (intInput % 2 == 1)
                eventHandler (intInput + " is odd");
            else
                eventHandler (intInput + " is even");
        }

        public static void Main (string[] args)
        {
            DelegateTester delegateTester = new DelegateTester();
            DelegateProvider delegateProvider = new DelegateProvider();
            
            delegateTester.raiseEvent(5, delegateProvider.handleEvent);
            Console.WriteLine("Return to quit.");
            Console.ReadLine();
        }
    }

    public class DelegateProvider
    {
        public void handleEvent(string strIn)
        {
            Console.WriteLine("Event raised: " + strIn + " -- and handled");
        }
    }
}

Labels: c#