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…)

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…)

I was working with Cody Collins and we ran into a problem recently with detecting whether the OS running was 32-bit or 64-bit from within NAnt. We’re trying to automate the installation of some software that has separate installers for 32-bit and 64-bit and we need to determine which installer to run from NAnt.

The problem begins with NAnt being compiled for 32-bit mode only which means all 64-bit functionality is transparent to it. If it weren’t for that, then we could simply depend on the PROCESSOR_ARCHITECTURE environment variable. So if you try to ask the OS if it’s 64-bit, it will tell you that it isn’t. Luckily there is an IsWow64Process WinAPI call that you can make to determine if you are running in WoW64. From these two pieces of information, you can infer whether or not the OS is 64-bit.

Cody and I were able to come up with the following scripts to determine this.

Note: This runs unmanaged code and does not protect you from crashes there – this could be better but this should get you 90% of the way there. This has been tested on Windows XP (32-bit), Windows 2003 (64-bit), Windows Vista (32-bit and 64-bit), Windows 2008 (32-bit), and Windows 7 RC (64-bit). Not an exhaustive test but it covers many of the bases.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

<property name="Is64BitOperatingSystem" value="false" />
<property name="Is64BitProcess" value="false" />
<property name="IsWow64Process" value="false" />
 
<target name="DetectOperatingSystemArchitecture" depends="DetectIfWow64Process,DetectIf64BitProcess">
	<description>
		This will detect whether the current Operating System is running as a 32-bit or 64-bit Operating System regardless of whether this is a 32-bit or 64-bit process.
	</description>
	<property name="Is64BitOperatingSystem" value="${IsWow64Process or Is64BitProcess}" />
 
	<choose>
		<when test="${Is64BitOperatingSystem}">
			<echo message="The operating system you are running is 64-bit." />
		</when>
		<otherwise>
			<echo message="The operating system you are running is 32-bit." />
		</otherwise>
	</choose>
</target>
 
<script language="C#" prefix="MyWin32Calls">
	< code>
		< ![CDATA[
			[System.Runtime.InteropServices.DllImport("kernel32.dll")]
			public static extern bool IsWow64Process(System.IntPtr hProcess, out bool lpSystemInfo);
 
			[Function("IsWow64Process")]
			public bool IsWow64Process()
			{
				bool retVal = false;
 
				IsWow64Process(System.Diagnostics.Process.GetCurrentProcess().Handle, out retVal);
 
				return retVal;
			}
			]]>
	< /code>
</script>
 
<target name="DetectIfWow64Process">
	<description>
		Detects whether we are currently in a WoW64 process or not.
	</description>
 
	<property name="IsWow64Process" value="${MyWin32Calls::IsWow64Process()}" />
	<echo message="Setting the [IsWow64Process] property to ${IsWow64Process}." />
</target>
 
<target name="DetectIf64BitProcess">
	<description>
		Detects whether we are currently in a 32-bit or 64-bit process (not necessarily what the OS is running). Note that as of the time of this writing, this will ALWAYS return false because NAnt is compiled to run in 32-bit mode only.
	</description>
 
	<!-- This can return x86, x64, AMD64, or IA64 as of the time of this writing. This works for a 32-bit process in a 64-bit OS because the OS makes the 64-bitness transparent to the process in this environment variable. -->
	<property name="Is64BitProcess" value="${environment::get-variable('PROCESSOR_ARCHITECTURE')!='x86'}" />
	<echo message="Setting the [Is64BitProcess] property to ${Is64BitProcess}." />
</target>

On a 64-bit OS, it has the following output:

D:\bin\deleteme\nanttest>build DetectOperatingSystemArchitecture
NAnt 0.85 (Build 0.85.2344.0; rc4; 6/2/2006)
Copyright (C) 2001-2006 Gerry Shaw
http://nant.sourceforge.net
 
Buildfile: file:///D:/bin/deleteme/nanttest/test.build
Target framework: Microsoft .NET Framework 2.0
Target(s) specified: DetectOperatingSystemArchitecture
 
   [script] Scanning assembly "lsbw4oxa" for extensions.
 
DetectIfWow64Process:
 
     [echo] Setting the [IsWow64Process] property to True.
 
DetectIf64BitProcess:
 
     [echo] Setting the [Is64BitProcess] property to False.
 
DetectOperatingSystemArchitecture:
 
     [echo] The operating system you are running is 64-bit.
 
BUILD SUCCEEDED
 
Total time: 0.2 seconds.
 
 
D:\bin\deleteme\nanttest>

Happy NAnting!!!

*heads off to the IndyALT.NET meeting on Continuous Integration now…*

I usually keep to technical topics on here but this one is going to take a step back.

In the past I have been a consultant through nearly my entire career. I have gone into new [to me] businesses, listened to what they wanted, helped them learn what they needed, helped them determine the correct solution for their need, often helped create these solutions or worked with the teams who created the solutions, helped the companies implement and deploy these solutions, helped with training, helped with post-deployment support, and anything else you can think of that goes with the territory. I have worked on single-person projects and have worked with teams ranging from 2 to 15 people. I have participated as a supporting developer, the lead developer, a supporting architect, the lead architect, a business analyst, and even a project manager on these different teams.

For the past year and a half, I have been working with the Indiana State Supreme Court on a project called eCWS. On this project I was the architect and lead developer in a team with 8 developers. My team and I designed, created, and maintained this entire system from scratch and won at least 3 international awards with the project. As of the time I rolled off of this project about a month ago the system had logged approximately 1 million citations and warnings, consisted of a laptop-based and PDA-based client (both of which were rock-solid and easily maintainable), a web-based client system, as well as some web-based server components while integrating with various electronic court systems (and of course most of these systems shared a common code-base to keep the code manageable).

Also, for the past year, I have helped to create the Indianapolis ALT.NET user group and have acted as the president of the user group. I have attempted to push a wonderful movement in furthering the community’s education on best practices and broadening the community’s range of thinking to more outside-the-box tools and techniques. As we are now, we are one of the most active and organized ALT.NET user groups in the world (and we’re about to step things up to the next level)!

For the past month I have done some consulting work for an older client of mine while waiting for negotiations and planning for “the big one” to come through. I’ve been ready to advance my career and, in doing so, will be stepping out of the consulting role I have been so successful in for years. Beginning today I will be joining the EnerGenuity team here in Indianapolis. EnerGenuity currently has a great software suite that keeps their customers happy (which include Fortune 500 and other companies). My official title, I think, is something like Technology and Product Development Manager (for the first time I’ll have a legitimate title and not one that I make up on-the-spot as so many software developers/consultants do!). In short, I will be leading the IT team for EnerGenuity. This is sure to be a challenging and rewarding experience in my life and I think EnerGenuity and I are a great match for each other! I think I have so much to offer and they have so much they need and the details in both of these seem like an absolutely perfect match!

So… that’s about it. Just thought I’d give you an update of what I was up to.

-Jax