Nokia Lumia 800 - Front

Yesterday, I visited a Telstra store to pick up a shiny new Nokia Lumia 800. After the OS on my trusty HTC Desire once again catastrophically failed, causing me to wipe it and reflash, it was time for a change.

In the past, I’ve had several Nokia phones running Symbian, a Sony Ericsson or two, one iPhone 3G, and most recently my Android running Froyo then Gingerbread. I’ve never had a Windows phone, and I’ve heard great things about Windows Phone 7.5, so I thought it was time to give it a try.

I’ve had the phone for about 24 hours now, and my impressions have been good for the most part. There are some incredibly impressive aspects to the phone and OS, but there are also a couple of fairly significant flaws with the blame shared between Nokia, Microsoft, and Telstra.

The Good

My first impression upon opening the box was, “This is a very good looking phone.”  It’s sleek and black and feels incredibly well put-together.  Of particular note is the “Clear Black” AMOLED screen.  When on, the blacks are so impressively black that it’s impossible to tell where the screen ends and the black surround starts.  It really helps bind the OS and the device together. Rather than feeling like a hand-held display with software on it, it feels like an integrated device.

Nokia Lumia 800 - Back

The speed of the device is a welcome change as well.  My HTC Desire took minutes from power-button-push to a usable phone; the Lumia takes less than 25 seconds.  Screen transitions and apps are very responsive and there’s no perceivable lag with touches or swipes.  Network connectivity seemed faster as well (even on the same network as the Android), probably due to some combination of the operating system and the hardware.  By the time I walked the device out of the store, I’d already connected the phone to my Google, Facebook, and Twitter accounts, and all my contacts were on the phone.  I had big issues connecting to my work’s Exchange server, but more on that later.

I was initially skeptical of the integrated “People” function on the phone that combines a contact’s details into a single “Person” complete with their Facebook, Twitter, and other accounts.  I had a similar function on my Android and I found it useful, but a bit clunky to operate.

Impressively, the phone identified and correctly linked about 90% of the contacts I had from Google, Facebook, and Twitter.  Almost all contacts had automatically been merged and the decisions around what were the primary details were very sensible.  Each person had an up-to-date profile picture from Facebook as well as all their contact details. In all cases, the correct name was shown (no “John Smith1″ or “johnsmith”).  Linking the few contacts that weren’t automatically merged was extremely fast. By the time I’d done three, I was taking less than 5 seconds to join two contacts together.  This short learning-curve was something that was visible throughout the first 24 hours and reflects very well on the WP7 operating system.

GPS location was impressively fast.  I had been used to a minimum 10 second delay on my android, but the Lumia found me on Bing Maps in a fraction of that time.

Nokia Lumia 800 - Lock Screen

I was also particularly impressed when I bought an app from the marketplace.  After agreeing to purchase, a message popped up telling me it’d be on my Telstra bill.  This is hands down the most convenient way to purchase an app. No need for another party to be involved when I’m purchasing things for my phone.

The Bad

Exchange.  This one baffles me.  I simply could not connect to our workplace Exchange Server (2010 SP1).  Not for lack of trying, either.  I scoured the web for solutions, spoke at length to our SysAdmins, and installed certificates left, right, and centre.  All to no avail.  I’ve never had this problem in the past; my Android spoke to Exchange like they were best buddies.  I find it inexplicable that Microsoft made the only device that can’t talk to our Microsoft mail server.  It’s a ridiculous situation.

Before you put pen to paper, yes, if you have a Windows Phone 7 (including the Lumia 800), there’s a good chance you have successfully connected to your Exchange server.  I have heard a number of people say they had no problem.  It seems hosted Exchange servers (e.g. Office 365) work fine, and there are workarounds for self-signed certificates.  Our server, however, uses a certificate from a CA (which should be trusted out of the box) and the phone just doesn’t seem to like that.  I’ll keep searching for a solution, but for the moment I’m assuming I just won’t be able to sync with my Exchange account.

Data on the phone has caused me some consternation as well.  While the speeds seem fine, the phone only reports 3G as its maximum network speed.  My Android happily showed an “H” symbol about 90% of the time at home, so I know I’m in an area with HSDPA service, but the Lumia refuses to recognise that it can run anything but 3G or Edge.  I’ve been passed between Telstra and Nokia support quite a few times at this point and nobody can give me an answer.  The phone is definitely the correct variant for Telstra, and the Lumia is capable of showing an “H”, so HSDPA speeds should be possible.

Tethering, while it has been supported by WP 7.5 for some time, has not been enabled on this phone.  Telstra offers nothing but a, “sorry, maybe soon” and no indication of an ETA.  This is a big deal for me. When travelling, my phone is my primary Internet device.  I’ve never bothered with a USB mobile device before and I don’t want to start now.  Telstra have other Windows phones that support tethering, so there’s obviously no technical reason it has to be disabled. They need to sort this out quickly.

Nokia Lumia 800 - Home Screen

The Too Early to Tell

The UI is something I’m still getting used to, but I don’t think it’ll take long before it’s natural.  As I mentioned, the learning curve for performing operations seems short and the OS is consistent throughout.  It’s already growing on me.

I haven’t installed too many apps at this point, but the ones I have installed seem pretty good.  In particular, AU Weather Pro and AFL Season 2012 are fantastic apps.  I haven’t had the opportunity to use Nokia Drive yet, but I’m looking forward to it.

The pre-installed Foxtel Guide app required an update before it would show me any information, and I had to actively search for that update.  I assume other apps will let me know when there is a new version, but it was a bit off-putting.

The battery life seems OK.  It was at about 25% when I unboxed it, so I kept it on charge for most of the day.  At 5pm it was at about 80% and by 10pm it was giving me low battery warnings which seems like a bad sign until you consider I was playing with it almost non-stop.  It’ll be interesting to see how it performs when I lapse into normal use.

Summary

In short, it’s a great phone.  It’s beautiful, fast, and has many impressive features.  Nokia has a fantastic device here, and Microsoft has obviously put a lot of thought and good engineering into WP7.

However the combination of no Exchange and no Tethering is very disappointing.  To be honest, if I’d known about these two issues before I got the phone, I probably would have waited.  Either for them to be resolved, or even for the Lumia 900.

Well, I’ve put together a generic Repository that can be used in your project to give you a consistent base class for all your repositories. It’s quite long, so sorry about that.

public class DataRepository<TContext> : IDataRepository<TContext> where TContext : ObjectContext
{
    // Cached ObjectSets so changes persist
    protected Dictionary<string, object> CachedObjects = new Dictionary<string, object>();
    protected ObjectSet<TEntity> GetObjectSet<TEntity>() where TEntity : EntityObject
    {
        var fulltypename = typeof (TEntity).AssemblyQualifiedName;
        if (fulltypename == null)
            throw new ArgumentException("Invalid Type passed to GetObjectSet!");
        if (!CachedObjects.ContainsKey(fulltypename))
        {
            var objectset = _context.CreateObjectSet<TEntity>();
            CachedObjects.Add(fulltypename, objectset);
        }
        return CachedObjects[fulltypename] as ObjectSet<TEntity>;
    }

    protected TContext _context;
    /// <summary>
    /// Constructor that takes a context
    /// </summary>
    /// <param name="context">An established data context</param>
    public DataRepository(TContext context)
    {
        _context = context;
    }

    /// <summary>
    /// Constructor that takes a connection string and an EDMX name
    /// </summary>
    /// <param name="connectionString">The connection string</param>
    /// <param name="edmxName">The name of the EDMX so we can build an Entity Connection string</param>
    public DataRepository(string connectionString, string edmxName)
    {
        var entityConnection =
            String.Format(
                "metadata=res://*/{0}.csdl|res://*/{0}.ssdl|res://*/{0}.msl;provider=System.Data.SqlClient;provider connection string=",
                edmxName);

        // append the database connection string and save
        entityConnection = entityConnection + "\"" + connectionString + "\"";
        var targetType = typeof (TContext);
        var ctx = Activator.CreateInstance(targetType, entityConnection);
        _context = (TContext) ctx;
    }

    public IQueryable<TEntity> Fetch<TEntity>() where TEntity : EntityObject
    {
        return GetObjectSet<TEntity>();
    }

    public IEnumerable<TEntity> GetAll<TEntity>() where TEntity : EntityObject
    {

        return GetObjectSet<TEntity>().AsEnumerable();
    }

    public IEnumerable<TEntity> Find<TEntity>(Func<TEntity, bool> predicate) where TEntity : EntityObject
    {
        return GetObjectSet<TEntity>().Where(predicate);
    }

    public TEntity GetSingle<TEntity>(Func<TEntity, bool> predicate) where TEntity : EntityObject
    {
        return GetObjectSet<TEntity>().Single(predicate);
    }

    public TEntity GetFirst<TEntity>(Func<TEntity, bool> predicate) where TEntity : EntityObject
    {
        return GetObjectSet<TEntity>().First(predicate);
    }

    public IEnumerable<TEntity> GetLookup<TEntity>() where TEntity : EntityObject
    {
        return GetObjectSet<TEntity>().ToList();
    }

    public void Add<TEntity>(TEntity entity) where TEntity : EntityObject
    {
        if (entity == null)
            throw new ArgumentException("Cannot add a null entity");

        GetObjectSet<TEntity>().AddObject(entity);
    }

    public void Delete<TEntity>(TEntity entity) where TEntity : EntityObject
    {
        if (entity == null)
            throw new ArgumentException("Cannot delete a null entity");

        GetObjectSet<TEntity>().DeleteObject(entity);
    }

    public void Attach<TEntity>(TEntity entity) where TEntity : EntityObject
    {
        if (entity == null)
            throw new ArgumentException("Cannot attach a null entity");

        GetObjectSet<TEntity>().Attach(entity);
    }

    public void SaveChanges()
    {
        SaveChanges(SaveOptions.None);
    }

    public void SaveChanges(SaveOptions options)
    {
        _context.SaveChanges(options);
    }

    public void Refresh<TEntity>(TEntity entity) where TEntity : EntityObject
    {
        _context.Refresh(RefreshMode.StoreWins, entity);
    }

    public void Refresh<TEntity>(IEnumerable<TEntity> entities) where TEntity : EntityObject
    {
        _context.Refresh(RefreshMode.StoreWins, entities);
    }

    #region IDisposable implementation
    private bool disposedValue;
    protected void Dispose(bool disposing)
    {
        if (!this.disposedValue)
        {
            if (disposing)
            {
                // dispose managed state here if required
            }
            // dispose unmanaged objects and set large fields to null
        }
        this.disposedValue = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }
    #endregion
}

A lot of code to be sure, but you only need one of these. After that, whenever you create a new EDMX, you can create a Repository that inherits from this base repository.

Let’s look at using it for the same AdventureWorks repository I used last time:

An Adventure Works Entity Model

Here’s how you might implement a repository for this data model:

public class AdventureWorksRepository : DataRepository
{
    public AdventureWorksRepository(string connectionString) : base(connectionString, "AdventureWorksEntities") { }
}

Yep, seriously. That’s it. Now you have access to all your common CRUD operations (as well as Linq queries) and can do things like this:

var repository = new AdventureWorksRepository(MyConnectionString);

// return all states and provinces
var states = repository.GetAll<StateProvince>();

// get states and provinces with a three letter code
var threeLetterStates = repository.Fetch<StateProvince>()
                                  .Where(s => s.StateProvinceCode.Length == 3)

// get a customer
var cust = repository.GetSingle<Customer>(c => c.CustomerID == 1);

// delete that customer
repository.Delete(cust);

// get a contact
var contact = repository.GetSingle<Contact>(c => c.ContactID == 1);

// edit some properties
contact.Title = "Mr";
contact.Phone = "61 411 111 111";

// save all the changes (this will save the customer deletion and the updated contact)
repository.SaveChanges();

So just by inheriting a base repository class, you can get some really powerful behaviour which is specific to your data model.

I’d be interested to hear your thoughts on this technique, particularly if you try it in your own project.

Previous versions of this talk have focused mainly on MVC 3 with a nod towards MVC 4. Now that the ASP.Net team have officially launched the beta of ASP.NET MVC 4, I’ll be shifting the focus to the new version.  Out with the old and in with the new!

If you saw the version of this talk I gave at DDD Brisbane last year, don’t be scared off – it’s gone through many, many iterations since then based on the feedback I’ve received.

So if you’re in Brisbane, I’d love for you to come along.  Just RSVP on EventBrite and I’ll see you there!

What about? Glad you asked.  The title is “Building Mobile Websites with ASP.NET MVC 3 and 4“.

It sounds fairly self-explanatory, but I’ll be covering more than just the obvious in this talk.  In addition to actually showing how to write mobile-targeted sites in MVC 3 and 4, I’ll be discussing:

• Why it’s important to think about mobile sites, and why people aren’t,
• How smartphones actually render a desktop site and what you can do about it,
• How mobile and desktop sites can coexist beautifully, and
• Why ASP.NET MVC is the perfect technology to deliver sites that look great on any device
• What libraries and packages are available to give you the best results

So if you’re in the Melbourne area on Monday, I’d love for you to come and check it out.  Just RSVP on EventBrite and I’ll see you there.

UPDATE: The slides are now available at http://brdy.in/mobilemvc

Most (good) developers talk about using the most appropriate technology for the job.  At its most basic level that means choosing Objective-C for a resource-hungry iPhone app, or writing your latest facebook-killer application for the web rather than the desktop.  That stuff’s obvious.  The more idealist polyglot programmers will take it further and push Ruby on Rails for web apps with a small budget, or they’ll suggest using RavenDB and deploying to AWS because all you need to do is store and retrieve documents across the web. If you’re in a Windows environment with a team running Scrum, choose TFS, C#, and SQL Server.

So “Horses for Courses” right?

The aim is valid and noble, and it’s certainly one I strive for.  But one thing frequently gets overlooked, and that’s the people on the team (or to stretch the metaphor – the jockeys).

If you have a team of programmers who are very used to writing software using certain technologies, think very carefully about advising them to move to something else. I’m not saying don’t do it (in some cases you really should), but there comes a point where the benefits to be gained by using language X on platform Y with source control Z just aren’t worth the trouble.

Unfortunately, most programmers write code in one way. They use one language, they know one data storage mechanism, and they’ve only ever written applications for one environment.  Maybe in a past life they tried out some other language, and maybe they dabble in HTML occasionally, but they’re only experts at one thing.

You, on the other hand, might look at a set of requirements and decide a NoSQL data store running behind RoR is the “best” solution for this project. Similarly, you recommend using git as the “best” source control system to use. Great. Unless you’re the only one who knows this stuff – then you’re dreaming.  If you have a team of C# developers, you’d want to have a pretty good reason for suggesting they program in a different language. If every other project they’re working on uses TFS, learning git is going to introduce a lot of overhead (initially).  Sometimes, the current way of doing things is the “best” way, even if the idealist in you disagrees.

Now, that’s not to say it’s never a good idea to force a shift within a team.  Consider a team of VB 6 developers who, for the last 15 years, have been dutifully writing VB windows applications with an Access back-end. At what point do you tell them it’s time to move on? (Ideally it would have been at least 5 years ago, but that’s clearly not an option). Assuming you don’t outsource or “refresh” the team, you should strongly suggest they change, but acknowledge that the extra effort they’ll have to put in will increase the work. Also be aware that you’re unlikely to get a quality solution from them if they don’t yet know what they’re doing.

My point is, when choosing the right technology for the job, consider everything, and that includes the skillset of the developers.

With that in mind, blog posts encouraging everybody to stop using .Net because it sucks, or telling them they should never use pure HTML and JS for business apps are just ridiculous. Yes, you might have had an overnight change of heart and now realise language X is the worst thing in the world, but you’re thinking about the specific situations you’ve been in, and developers with specific skills (usually just the individual author). If your whole team can just up and move to Ruby, then fantastic! Say hi to the rainbow coloured unicorns for me!

It’s always good to encourage teams to learn new technologies. It’s occasionally good to force a team to move on, but sometimes the “best” way isn’t the “ideal” way.

How to be a Good TFS Master

I recently gave a talk at the Qld ALM User Group on the topic of “How to be a good TFS Master”.

Hopefully those who turned up got some great tips on how to use TFS more fully, but the main points I hoped people left with were:

Most people only use about 20-30% of the capabilities of TFS

In our experience, the majority of companies using TFS are using it for source control only.  SSW helps teams get closer to using 80 or 90% of TFS where the real advantages can be felt. There are some fairly significant infrastructure costs associated with getting to 100%, and we find most organisations don’t want to go that far.

TFS is much more than source control

In fact, if you’re using TFS purely for source control, you’re doing it wrong! You might even be better off using Git or Mercurial.  The best option (of course) is to start using TFS more fully to help you get the best out of your team.

TFS supports your Scrum process beautifully

TFS has some awesome capabilities that allow you to manage and support your entire scrum process. The integration story is compelling; allowing you to tie code changes directly to user stories, produce genuinely useful reports for your managers, and enforce your policies and coding standards allowing you to tick items off your Definition of Done without any effort.

For more information or some reminders of what I spoke about, have a look at the slides on Slideshare - http://www.slideshare.net/damovisa/how-to-be-a-good-tfs-master

I’m working with a client at the moment on a system using legacy database with (wait for it) about 50 lookup tables in their database.  We’re using Entity Framework to access the database, so it’s fairly easy to get the data out of these lookup tables.

However, I really don’t want to write 50 methods to return lists for each of these objects.  Thankfully, the solution is relatively simple – write a generic method to return the appropriate data.

Implementing this wasn’t quite as easy as I thought, but I got there after a bit of experimentation and, I’ll be honest, a fair bit of googling.

To demonstrate, let’s look at an Entity Model with a subset of the AdventureWorks database.

An Adventure Works Entity Model

In particular, look at the red outlined objects.  These are likely to be referred to frequently throughout the application as simple lookup tables.

We want to write a single generic method that will return an IEnumerable of these objects so we can use them quite simply as lookup tables.

Here’s what I ended up with:

AdventureWorksEntities adventureWorksEntities = new AdventureWorksEntities();
 
public IEnumerable<T> GetLookup<T>() where T : System.Data.Objects.DataClasses.EntityObject
{
    try
    {
        var key = typeof(T).Name;
        // 1. we need the container for the conceptual model
        var container = adventureWorksEntities.MetadataWorkspace.GetEntityContainer(
            adventureWorksEntities.DefaultContainerName, System.Data.Metadata.Edm.DataSpace.CSpace);
        // 2. we need the name given to the element set in that conceptual model
        var name = container.BaseEntitySets.Where((s) => s.ElementType.Name.Equals(key)).FirstOrDefault().Name;
        // 3. finally, we can create a basic query for this set
        var query = adventureWorksEntities.CreateQuery<T>("[" + name + "]");
 
        return query.ToList();
    }
    catch (System.Data.EntityException ex)
    {
        throw new ArgumentException("Invalid Entity Type supplied for Lookup", ex);
    }
}

Now we can use the following code to return a set of all items of the appropriate type:

AdventureWorksRepository repository = new AdventureWorksRepository();
var states = repository.GetLookup<StateProvince>();
var addressTypes = repository.GetLookup<AddressType>();
var territories = repository.GetLookup<SalesTerritory>();

This has saved me countless hours of writing boring plumbing code.

Hopefully, some of you are already looking at this thinking, “couldn’t I take this a lot further and provide a set of generic data access methods for everything?”. The answer of course is yes.  I haven’t gone quite that far yet, but I wouldn’t be surprised if it was down the track.

The problem was that this was a live site that received several thousand hits a day. I wanted to be able to quickly find my specific requests in the IIS log.

My solution?  Give my browser its own User Agent string.  That way I can search for my specific entry in the appropriate log file.

I was using Firefox for this investigation.  It’s fairly easy to change your User Agent string:

• Go to about:config in the address bar of Firefox
• Right-click in the window and choose New | String.
• Call the Preference Name, “general.useragent.override” and set the Value to something you’ll recognise.  It’s usually safer to take your existing User Agent string (which you can find at http://whatsmyuseragent.com/) and just append something unique.
• Go to http://whatsmyuseragent.com/ and make sure your change has persisted.

To undo your change later, just return to about:config and delete your override entry.

Now when looking through the IIS logs, you can just search for your specific User Agent string to find your entries.

Tip: See here for instructions on changing your User Agent in Chrome, and here for some help in IE 8.

Using WebcamViewer to show a webcam on your computer desktop

I went along to see Leon Bambrick and Joseph Cooney at the Queensland MSDN User Group meeting last night. The attendance was amazing – they had to open up a partition to the adjacent room and every seat was filled.

Leon and Joseph spoke about ASP.NET MVC 3 with a particular focus on the tooling around it, and delivering sites for mobile devices.

One slightly off-topic tip I did pick up was from Joseph when he needed to show his MVC site on different mobile devices. It’s a simple tip, but very effective.

Tip: To show a mobile device, use a webcam:

1. Hook up a USB webcam to your presentation laptop
2. Point the webcam at the mobile device on your desk
3. Show the webcam screen on your computer/projector (I recommend WebcamViewer)

Pretty easy, huh?

The key point for me is that using a camera pointed at an actual device gives maximum believability.

You can use an emulator or a browser with a spoofed user-agent string, but it won’t engender as much trust with the audience. In particular, using a browser or emulator with the full power of your computer behind it can make things appear nicer than they actually are; particularly when it comes to site performance and demonstrating a touch device with a mouse.

For more presentation tips, see the SSW Rules to Better Powerpoint Presentations.

You may remember me briefly talking about this topic in an earlier post, as it’s something that I’m fairly excited about.  The general idea is that most software just does exactly what the user asks.  You give it some explicit input, it gives you some output.  Participative Software is my name for software that makes suggestions and “participates” without explicit input.

Watch the video for more details.

The five minute time limit meant that I didn’t quite get my point across as well as I’d hoped.  I’d like to present the topic over 20 or 30 minutes so I can really drill down on the subject and include a bit more of a call-to-action.

As always, feedback is more than welcome – especially if you’d like to hear a 30min version!