There has been a LOT of misinformation floating around about the Droid X. I can’t count how many times I have heard rumors that have been made up instead of coming from the reliable sources (i.e. the people who have had the device, the people who leak the information, etc.). So I thought I would clarify here everything as I know it. Now keep in mind, the phone has not yet even been announced, so there is most certainly the chance that anything can change. For all we know, maybe Verizon has scrapped Android and put WebOS on it! (Not really, but keep in mind that things can change, even from the devices that people have personally seen.) So while nothing is locked in stone yet, I’m trying to filter out the unreliable rumors from the reliable rumors.

Misinformation Summary

	Unreliable Rumor	Reliable Rumor
Screen Resolution	720p	854×480
Screen Size	4.4″	4.3″
Android Version	FroYo (Android 2.2)	Eclair (Android 2.1)
Release Date (Date in YOUR hands)	June 23	July 19
CPU	Snapdragon	720MHz or 1GHz OMAP3 CPU
Front-Facing Camera	Yes	No

Screen Resolution

First off, take a look at the official Verizon and Motorola pages for the device. They don’t say much, but I’m sure in a few days they’ll be a bit more interesting. The main comment I have here is that Verizon temporarily and erroneously listed “720p screen” on the official page before updating it and changing it to “Captures 720p”. So this is one source of misinformation that many people are blogging about. Engadget, among many others, confirm this. To reiterate, the Droid X does NOT have a 720p display! At this point, the reliable rumor is that the display’s resolution will be 854×480, the same as the original Droid, based on Engadget, the people who actually had hands-on time with the phone.

Droid X or Droid 2?

Now that we have looked at the mostly useless official pages, let’s next discuss the phone’s identity itself. The rumormill is going on and on about the Droid X and only some of them mention that a second phone is being talked about at the same time: the Droid 2. The Droid X is supposed to be a 4.3″ screen-only phone while the Droid 2 is a 3.7″ w/physical keyboard phone. I have seen more than one report confuse the two and not even realize that they are different phones. So keep this in mind in your reading. (As far as I know, Verizon/Motorola has not yet officially acknowledged the existence of the Droid 2 phone, only the Droid X.) Lots of reports are confusing the rumors/specs associated with one phone for the other.

Eclair? Frozen Yogurt? Hot Fudge Sundae?

Next, let’s talk about the operating system version. Various sources are reporting that it will run Eclair (Android 2.1) while others are claiming it will run FroYo (Android 2.2). However, I have not seen any of them to have a reliable source for the claim that it will run FroYo. Rather, the only reason to believe this is a possibility is because of a widget that has been displayed on the Droid X that is supposed to come with FroYo and has not been included in Eclair yet. This is where the confusion between Droid X and Droid 2 comes into play. Droid X is supposed to be in consumers’ hands on/about July 19 while the Droid 2 is speculated to be released in August. As such, the Droid 2 has a bit more time to get FroYo ready for it whereas the Droid X doesn’t have as much time and is supposed to launch with Eclair. This is based both on Engadget’s hands-on time with the phone as well as what a couple reports have been told has come from “reliable sources”. I have yet to see a “reliable source” for the FroYo claim.

Release Date

Most people agree that the Droid X will be announced on June 23 based on the invitations that many different news agencies received. Note the execs from Motorola, Verizon, Google, and Adobe who will be there. There is plenty of speculation about Adobe’s role in this but nobody really knows anything about this right now. While the phone is announced on June 23, some reports are saying (or at least implying) that it will be available on June 23 and this is an unreliable rumor. The reliable rumor is that it will be in consumers’ hands on July 19. As for the Droid 2, the rumor is August but I think this is mostly speculation at this point with no reliable source for it.

Processor

So this is one area where I am unsure of what exactly to expect. There has been multiple lines of rumors about this and I’m not sure which one to believe. One line claims that the phone will have a OMAP3630 CPU. Another line claims that it will have a 1GHz processor. And some claim that it is a 1GHz OMAP3630 CPU. However, there are problems with some of these rumors. As you can tell from TI’s offerings, the 3630 is a 720MHz model while the 3640 is a 1GHz model. Some of the people are saying the 1GHz CPU will be a Qualcomm Snapdragon CPU, even, but I suspect this is simply based on an assumption because that’s the only 1GHz CPU they’re familiar with. All in all, I’m not sure what to believe here. If it truly is a 1GHz OMAP3 CPU (whether the 3630 at a faster clock speed or the 3640), I think it would be a welcomed improvement over the pseudo-standard Snapdragon.

Another comment to make about the CPU is that the common rumor used to be a 720MHz OMAP3630 until some advertisement information leaked (that, mind you, did NOT mention a thing about the Droid X’s processor speed, only the Droid 2 processor speed). I’m not really sure what the source is that the Droid X’s CPU will be a 1GHz processor but it seems to be what everybody is reporting now. I still am unsure about this. However, keep in mind that a 720MHz OMAP3630 is still comparable to a 1GHz Snapdragon for general use and better for 3D gaming.

Front-facing camera

So I’ve seen more than one report that this will have a front-facing camera. I have only seen this reported from sites that seem to have no real source and are probably just making this information up. As far as everything I’ve found that seems reliable, there will be NO front-facing camera on the Droid X. And yes, this is a shame.

Screen Size

I have seen reports of both a 4.3″ screen and a 4.4″ screen. The 4.3″ screen is what was reported by Engadget (who physically had the device) and is what Verizon shows on the official page. I don’t know what the source is of the 4.4″ screen rumor is but a LOT of reports suggesting it. They seemed to have died down lately, but I have still seen a couple reports even today that are still claiming it has a 4.4″ screen. At this point, I think it’s pretty much definitely a 4.3″ screen. But are all 4.3″ screens the same? I’m not so sure. This screen does appear to be longer in the photos displayed next to an HTC Evo 4G (photos reported by a LOT of places but appear to originate here). Considering that the resolution is slightly higher, this could mean that the display is a bit narrower than the Evo, so this could explain how it could appear larger but really be the same size, since the size is measured as a diagonal from corner to corner.

There you have it! I think that takes care of most of the misinformation that I’ve been seeing. Like many others, I can’t wait to get my hands on this device!

I find myself rediscovering how to do this a lot, so I thought I’d post this here.

1. Create your Account (let’s say it’s MyDomain.com\sa_MyMVCHostingUser in your company’s Active Directory server – it can also be a local Windows account as well)
2. Open up an elevated command prompt (Start -> “command” -> [CTRL]+[SHIFT]+[ENTER])
3. Navigate to your .NET Framework directory (such as C:\Windows\Microsoft.NET\Framework\v4.0.30319)
4. execute: aspnet_regiis -ga MyDomain.com\sa_MyMVCHostingUser

After performing the above steps, your account will have the basic permissions to host a basic ASP.NET application. If you are accessing resources other than the IIS Metabase or content files in your IIS Application, then those permission configurations are beyond the scope of this post (and you would NOT set them up in a similar way, so don’t try).

With my venture into MVC2 recently, I’ve fallen in love with the strongly-typed helpers and am attempting to provide mechanisms similar to those in many different areas of my code so I can cease the use of hardcoded/constant strings all over the place and get better compile-time error checking.

This post is to show you how you can use Lambda Expressions to perform these sorts of things in an N-Tier system in a way where you can even serialize these expressions. I’m only handling a very basic scenario here but the tools I use are VERY flexible and can handle, out-of-the-box, much more complex scenarios.

So the setting where I’m using this in is within MVC where a grid is displaying paged data and I’d like to filter and sort the data. For this post, let’s look at the dynamic sorting options. Not only do I want to sort the data, but I also want to support multi-column sorting. However the UI implements this, I don’t really care but I want to expose a strongly-typed way for it to do so, if it chooses (i.e. as the default so future coders are less likely to create bugs that sneak into production).

In order to do this, I’ve created a fairly simple class to store these sorting options. I share both on the UI side and the server side of WCF as this is acceptable in my system. However, I do so in a way that COULD be consumed by any other technology while losing the strongly-typed functionality but not losing all functionality. Here is my initial version of this class:

    public class SortOption<TModel, TProperty> where TModel : class
    {
        public SortOption(Expression<Func<TModel, TProperty>> property, bool isAscending = true, int priority = 0)
        {
            Property = property;
            IsAscending = isAscending;
            Priority = priority;
        }
 
        public SortOption()
            : this(null)
        {
        }
 
        public Expression<Func<TModel, TProperty>> Property { get; set; }
 
        public bool IsAscending { get; set; }
 
        public int Priority { get; set; }
    }

Pretty simple, right? This actually is a VERY simple class with the exception of that pesky Property object with the nasty Expression<Func<TModel, TProperty>> signature. In case you didn’t know, that nasty signature is how we would write code such as foo.Property = (x => x.FirstName); in order to say that we want the “FirstName” property off of whatever object we instantiated foo with as TModel (whether it’s a Person class or a Pet class or whatever). Because of that nasty Expression signature, there’s no way this is going to serialize nicely, or at all. Lots of Googling all over, everybody tells you that you simply cannot serialize Lambda Expressions, don’t try!

Luckily for us, they are only partially correct. It depends on what you want to do with that Lambda Expression that determines if you really can serialize it or not. All we’re using it for is to have strongly-typed code at development time. At run-time, it does nothing for us and in actuality is a slight performance hindrance. But this is the age of sacrificing performance for developer productivity, so this is okay (at least for some). So with the help of some Dynamic LINQ Libraries (haha!!), we can actually serialize these expressions that we’re wanting to use in this scenario! ScottGu has a nice post introducing these and I encourage you to read it. What we are using, as ScottGu mentions, is the code in the Dynamic.cs file in the “\LinqSamples\DynamicQuery” project.

Take a looksee through the Dynamic.cs file and you’ll see a static DynamicExpression class with some ParseLambda functions in there – these are the things that we care about mostly for this. As you can see, these functions are quite powerful and flexible.

Once we make some slight modifications to our SortOption<TModel, TProperty> object to implement ISerializable, we can leverage one of those ParseLambda functions to perform the hard part of our custom serialization of this class. Below is a newer version of this class, all with nice comments, to do exactly what we’re wanting to do:

    /// <summary>
    /// This defines a framework to pass, across serialized tiers, sorting logic to be performed.
    /// </summary>
    /// <typeparam name="TModel">This is the object type that you are filtering.</typeparam>
    /// <typeparam name="TProperty">This is the property on the object that you are filtering.</typeparam>
    [Serializable]
    public class SortOption<TModel, TProperty> : ISerializable where TModel : class
    {
        /// <summary>
        /// Convenience constructor.
        /// </summary>
        /// <param name="property">The property to sort.</param>
        /// <param name="isAscending">Indicates if the sorting should be ascending or descending</param>
        /// <param name="priority">Indicates the sorting priority where 0 is a higher priority than 10.</param>
        public SortOption(Expression<Func<TModel, TProperty>> property, bool isAscending = true, int priority = 0)
        {
            Property = property;
            IsAscending = isAscending;
            Priority = priority;
        }
 
        /// <summary>
        /// Default Constructor.
        /// </summary>
        public SortOption()
            : this(null)
        {
        }
 
        /// <summary>
        /// This is the field on the object to filter.
        /// </summary>
        public Expression<Func<TModel, TProperty>> Property { get; set; }
 
        /// <summary>
        /// This indicates if the sorting should be ascending or descending.
        /// </summary>
        public bool IsAscending { get; set; }
 
        /// <summary>
        /// This indicates the sorting priority where 0 is a higher priority than 10.
        /// </summary>
        public int Priority { get; set; }
 
        #region Implementation of ISerializable
 
        /// <summary>
        /// This is the constructor called when deserializing a SortOption.
        /// </summary>
        protected SortOption(SerializationInfo info, StreamingContext context)
        {
            IsAscending = info.GetBoolean("IsAscending");
            Priority = info.GetInt32("Priority");
 
            // We just persisted this by the PropertyName. So let's rebuild the Lambda Expression from that.
            Property = DynamicExpression.ParseLambda<TModel, TProperty>(info.GetString("Property"), default(TModel), default(TProperty));
        }
 
        /// <summary>
        /// Populates a <see cref="T:System.Runtime.Serialization.SerializationInfo"/> with the data needed to serialize the target object.
        /// </summary>
        /// <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> to populate with data. </param>
        /// <param name="context">The destination (see <see cref="T:System.Runtime.Serialization.StreamingContext"/>) for this serialization. </param>
        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            // Just stick the property name in there. We'll rebuild the expression based on that on the other end.
            info.AddValue("Property", Property.MemberWithoutInstance());
            info.AddValue("IsAscending", IsAscending);
            info.AddValue("Priority", Priority);
        }
 
        #endregion
    }

With this simple custom serialization implementation, we can now have strongly-typed, serializable Lambda expressions and hopefully prevent sneaky bugs getting in there. Granted, when we serialize/deserialize this, we’re convert it to simple bug-tolerant strings, but this is the ugly plumbing work that you tend to not change that much. And also, when you break it, it tends to be pretty obvious and not very sneaky. So that’s okay. And from another perspective, good luck serializing anything if you can’t convert it into a string of some sort!

Way back in WinXP times and before, I would always connect all of my PCs at one desk together to a single set of speakers. The only special software/hardware this required were some extra 3.5mm audio cables and a set of ordinary speakers. The software to do this was built into Windows XP and just required some intelligent checkboxes to be selected. However, the native ability to do this with both Windows Vista and Windows 7. Luckily, with a registry hack, it is possible to still get this behavior with both operating systems!

(more…)

I’ve been tasked at coming up with a standard architecture for us to apply to our future projects. Yeah, I know, there’s no blanket answer for everything, but given the requirements I expect, I think a single architecture can handle 95% of what we’ll be doing and we can deviate/improve as necessary for the other 5%.

Ultimately I don’t yet know what this is going to look like but this is the direction I’m leaning in:
(more…)

On Day 0 of Microsoft PDC, I attended the Software in the Energy Economy workshop. Much to my surprise (and disappointment), we didn’t talk about energy for the entire first half of the workshop. Instead, it was about Azure’s Service Bus. BAD Microsoft!! It was explained to us by Juval Lowy that he wanted to do it entirely on energy but Microsoft forced him to have half of the talk on the service bus. Now I can understand this from Microsoft, but this should have been clear to the people there. Honestly, I would have much preferred to go to another workshop than to learn about the Azure Service Bus. Cool stuff but my current analysis of it is that it’s way too unreliable (I don’t mean bugs, I mean lack of transactional support) and it is simply missing some of the things that I would want/need in such a system, like queues! There are hacks to implement them, but I don’t want to have such an important foundational part of my architectures built on hacks! Anyways, that can be for another day (gotta get to the keynote).

(more…)

So I was performing some maintenance work on some webform stuff in an application and ran into a problem where an existing custom control, which I have the source for so I can fix it (yay!), wasn’t properly disabling itself when it was in a container that became disabled. The way it works, it overrides the rendering process and spits out lots of HTML and javascript (eww!) but for the important things for this rendering, it looks at a custom “ReadOnly” property on the control to enable/disable the appropriate things. So essentially the control is always enabled except when that flag is set to false – a bad idea!

(more…)

Like many others, I got my Android G-1 phone a couple days before it was officially released and have been longing for when Indy would finally get 3G coverage. Lo and behold, I get out of the shower this morning to check the weather and my 3G icon is lit up, albeit with only 1-2 bars (out of 4). Did some surfing and it seemed to load quickly just like it has when I’ve traveled to 3G cities (San Diego, LA, Chicago, etc.).

(more…)

With Windows 7 and Windows Server 2008 R2 recently going RTM, I’ve found myself installing them in quite a few different configurations. One configuration that I’ve recently ran into is installing it into a machine with no CD drive of any means. I know I could carry around a USB-based DVD drive but instead, I wanted to have a USB pen drive to install it from. After some research, I found that it was relatively easy to create such a tool!

(more…)

Yesterday I got the thumbs up that I’m being sent to PDC 2009 by my company! I planned on going whether I was sent or not but it’s nice to not have to foot the bill out of my own pocket this year. In 2005 I was lucky enough that my company covered airfare and hotel while Telerik was generous enough to cover my registration for the conference and the pre-conference. Last year I wasn’t so lucky and had to cover almost all of it out of pocket but that’s what you expect as a contractor.

Here’s what I have to do:
(more…)