Australian SharePoint conference 2010 – day 1(3 min read)

Keynote (Arpan Shah)
Some of the slides were re-used from other presentations (e.g. Services Ready content), but a reasonable overview. One thing particularly interested was some statistics that were provided: 17,000 SharePoint customers, 4,000 SharePoint partners, and 500,000 SharePoint developers.
The developer stats seem a bit iffy, but the customers/partner information is interesting -- if you do the maths it works out at 4 customers per partner, which gives an idea of the level of competition in this space.
Manipulating the SharePoint 2010 Ribbon (Todd Bleeker)
Todd is a very enthusiastic presenter, and provided plenty of side tips and suggests that are obviously based on experience, e.g. "Start with an Empty SharePoint project rather than with a specific item, so that you can give the item a nice name when you add it", or "The first thing I do is move the key.snk into the Properties folder because I never touch it and want to clear the screen real estate".
The presentation had a good mix of slides and demos, and continued with the tips, e.g. "Deploy .js files into a library so you can apply security management -- such as making them accessible to anonymous users.". He then went on with issues how the blank site template doesn't have a Site Assets (or Site Pages) library, so you need to also ensure they exist.
Taking SharePoint offline with SharePoint Workspace
I don't know what I was expecting from this business track presentation, but it did deliver on some of the changes/improvements in SharePoint Workspace (previously Groove) and the limitations.
I think SharePoint workspaces are a good solution for the 'occassionally disconnected' worker, but you need to think how you organise your SharePoint to support it, e.g. having one site with a large document library (with folders, etc) doesn't synchronise well (you can't limit SPWS to only part of a list); you want to have individual collaboration sites per department, project, etc.
Developing with REST and LINQ in SharePoint 2010 (Todd Bleeker)
Another good presentation by Todd, which covered two extremes of accessing SharePoint data. Half the demo was on the JS Client Object Model, and the other half jumped right to the other end of the spectrum and show cases using LINQ on the server-side to access SharePoint data.
DataView web parts
This presentation was plagued by demo issues and suffered a bit. It was also oriented towards no-code solutions, so limited in scope. It did show how far you can get through only customising dataview webparts (XSLT, etc).
There was also a nod towards the new client-side object model and the potential for developing significant solutions without the need for any server code.
Building Line of Business Applications using ECM solutions
I found this presentation a bit bizarre. The presenters started off selling themselves and it initially felt like I was in a vendor session. Whilst other sessions may give away books, CDs, etc, these presenters decided to give away five dollar notes, which I found quite strange.
Another example of something that struck me as strange was presenting some statistics about the types of successful projects but drawing the wrong conclusion regarding how likely a project is to be successful based on its type (affirming the consequent fallacy -- "a lot of successful projects are type A" does not mean that "type A projects are likely to be successful" -- maybe there are simply more type A projects).
The bulk of the session was actually an okay case study about building a demo OH&S business process consisting of an Infopath form for incident reporting kicking off a workflow that then led to a case management workflow (where necessary). The case management workflow used the new document set functionality, where a special folder (call a document set) of items can be group together, applying metadata, workflows, records management, etc to the document set as a whole.
(As an aside, if you want to take advantage of SharePoint Workspaces then you need to think carefully about how you structure you documents -- do you really want all cases in a single document library.)

Application Lifecycle Management conference – day 2(3 min read)

.NET 4 - Alex Mackey
This is a broad topic to cover in only 1 hour, and what is important will vary depending on what areas you work. Alex did a good job of covering some of the essentials (such as the new runtime and side-by-side deployment) as well as some of the cooler features. Things like co-variance / contra-variance may have gone over the heads of some of the audience, but the presentation as a whole was well done.
The actual presentation itself was also very punchy, with good use of images (a bit of humour helps keep things interesting) and hilighting of the important parts of slides. Plenty of good demo code as well.
Lessons learned from agile - Richard Banks
Some valueable recommendations "from the trenches", although I don't know if the limited number of slides quite worked. I presume the intention was to make it more conversational, but (for me at least) it did seem a bit lacking. The content fit the ALM side of the conference well.
Build framework enhancements - Stephen Godbold
Continuous integration, or at least daily builds, is a key element / best practice in any modern development practice, and it is good to see the enhancements in this area. There is a good story around extensibility, which the demos showed well, although I do worry whether a workflow based solution is getting too complex (compared to a simple build script.)
Still, even the out-of-the-box features seem a big step forward. The presentation also demonstrated some good practices, e.g. unit testing of custom build enhancements.
Introducing ALM to SharePoint - Jeremy Thake
Having led SharePoint development in the early days of MOSS 2007 the developer experience was pretty much a complete disaster. Ah, the simple joy of being able to hit F5 and debug into a SharePoint component, and on a workstation OS!, or of having a build server deliver a SharePoint deployment package (without third party tools and custom scripts).
The improvements may have been lost on those in the audience who hadn't struggled with MOSS before, but the presentation did a good job of relating the experience back to the central theme of ALM. Hopefully it convinced those present that SharePoint was now a more viable option.
Agile Database Development - Peter Ward
This presentation was a bit of a disappointment. It failed to deliver on some of the promised content (e.g. unit testing of T-SQL was not covered), and, while it did mention integration with TFS and other ALM features, these weren't really shown in the demonstrations.
I think demos similar to the Build framework enhancements, showing actual integration with continuous builds, etc would have been better. There was discussion in the talk, but no demo.
Windows Phone 7 Development - Dave Glover
An interesting presentation to end the conference. The XNA demo suffered from technical problems, which did disrupt the flow, but the presenters managed to carry on regardless and did a decent job. Windows Phone 7 will be an interesting platform to watch, but is obviously a version 1 product (e.g. no plans for cut & paste).
The presentation was also quite a different style than others -- a long list of discussion points and links to other content, rather than a set of slides, but I think it worked well for the content.

Australian ALM (Appliction Lifecycle Management) Conference(2 min read)

I spent the day at the inaugural Australian ALM conference today. Here are some impressions from the sessions I attended:
VS 2010 launch - Microsoft
VS is maturing a lot as a testing platform (automation, bug tracking), and this was featured in both Sam & Tanuj's portions of the launch. The launch event was free, and had a lot more attendees than the later conference portion. Handouts include a neat pack of planning poker cards with Microsoft branding.
Keynote - Dr Ivar Jacobsen
I've written before about Ivar's comments on Method Needs Theory, and it was great to hear him talk. His recent work on Essential Unified Process is available as a VS 2010 process template, with Use Cases, Use Case Modules, etc. It is a good reminder to hear from one of the earlier pioneers of iterative and other best practices just how long these concepts have been around, and the need to be aware when concepts like agile become overloaded with hype.
Personally, I prefer the structure that Use Cases give, compared to 'epics' and 'themes' in the User Stories world, particular the early focus on system boundaries, stakeholders and goals to give meaningful context. Like any other methodology UP (Unified Process) can be easily abused, e.g. hundreds 'use cases' instead of the 10-12 that a typical system should have.
VS2010 IDE Enhancements - Alex Mackay
A grab-bag of some of the new features in VS, with some quirky examples of extensions. Fairly limited in what you can get through in 1 hour, but plenty of good practical examples. The session was presented well, and the audience seemed to like it a lot.
Sketchflow - Mitch Denny
In the first half Mitch used an interesting presentation tool, Prezi, that I hadn't seen before. I worked kind of like a mind-map, drilling down into different 'slides' as necessary. The second half had plenty of demos, but it might have worked better with more switching between slides & demos, rather than two separate halfs.
I very much like Sketchflow, especially using sketchy styles for prototypes, but I don't know how well it will grab on as a separate tool. Hopefully it will gain traction in the designer community, but the interface is quite different for someone used to a coding tool like VS.
Introducing Agile: Microsoft Developer Division - Sam Guckenheimer
An old presentation (although I hadn't seen it before), mostly on the use of agile practices to deliver VS 2008. It did seem a bit dated, but had a good chunk of information (but no demos -- nothing really relevant to demo). Definitely more ALM than VS.

Book review – Agile Project Management with Scrum / Ken Schwaber(2 min read)

I just finished reading “Agile Project Management with Scrum”, but the Scrumm man himself (Ken Schwaber), so thought I would share a quick review:

Book review - Agile Project Management with Scrum / Ken Schwaber

This book uses a series of case studies to examine solutions to various complications that can arise in a Scrum (or any other) project. The case study format is informative and reasonably well written, although it doesn't have the rigor or authority of more quantitative studies.

I would recommend the book for any project managers (/Scrum Masters) that are involved in a Scrum project; it's a short enough read that they should get value from reading it before or at the start of a new project. The book also has a quick overview of Scrumm – a good reminder if you aren’t that familiar with the process.

Examples focus on the different roles and artefacts of Scrumm, focussing on guidance for each area. One section I found particularly good was guidance for scaling Scrum projects (using a timeboxed "Staging" process to define the required non-functional scalability requirements as requirements).

Some of the examples given really demonstrate the power of iterative methodologies and focussing on delivering business value. One particularly memorable example (p.19) was introducing Scrum on a project to automate import of land ownership changes from various state governments; the project had failed twice before.

By focussing on delivering "potentially releasable" software in the first iteration (4 weeks), focussing on hte highest value feature. The business then decided to actually release it (in a short, 2 week, second iteration), reducing their workload by 40% after only 6 weeks.

The book is relatively thin (around 160 pages), which always gets high points to me, so it is a relatively quick read. Although tied to the Scrum method, it does have some longevity (compared to books around specific technologies). Some of the examples are useful for general iterative development even if you aren't doing Scrum or even if you are using a heavier (non-agile) iterative process.

One thing that constantly irked me was the author confusing Gantt charts and something that is like a PERT network diagram (p.88), calling it a "Gantt report"; I know its picky, but it just really annoyed me and detracted from what is otherwise a reasonably good book.

I would give it 3.5 / 5 as a general software project management book, compared to classics such as Peopleware or the Mythical Man Month. As a book about Scrum, however, I would give it 4 / 5.

Reflections on SOA(2 min read)

One way I expand my professional knowledge is by reading "good" books on software engineering; those books that are either commonly referenced classics or highly recommended (see sidebar for short reviews of some recommended books).

I have recently been reading "Pattern-Oriented Software Architecture, volume 1", by Buschmann, et al. (commonly referred to as POSA), which includes one of the early (1996) formalisations of the Layers pattern.

What does this have to do with SOA?

Well, the topic came up in a recent training course of what is SOA / what is a service. The training course level was such that only a basic description was appropriate, but what immediately jumped to my mind as important is that a Service Oriented Architecture usually consists of both coarse-grained business services, as well as fine-grained implementation services (often with a workflow component as a means to aggregate them).

Although a lot of knowledge can be learnt on the job, being passed on by other software engineers, it can sometimes be an eye-opener to actually go back and read the original description.

In this case, when defining an Service Oriented Architecture I would strongly suggest reviewing the Layers pattern and think about how your services might be structured in layers. Think about the different abstraction levels you have in your system, name the different layers and assign tasks to each of them. In particular, think about some of the issues from step 4 ("Specify the services"), and step 5:

"5. Refine the layering. Iterate over steps 1 to 4. It is usually not possible to define an abstraction criterion precisely before thinking about the implied layers and their services. Alternately, it is usually wrong to define components and services first and later impose a layered structure on them..."

One way I have seen service oriented architectures broken up is with different layers for Business Process Services, Business Function Services and Data Services, each with their own responsibility and features.

For example Data Services encapsulate business data entities specific to a slice of the business and are usually atomic, stateless, don't change often and are highly reusable, whereas Business Process Services are designed to encapsulate business process and workflow, are implemented through a stateful orchestration and will change more often.

There is a good diagram of how the different abstraction levels (Layers) of services can interact in "Understanding Service Oriented Architecture" in the inaugural January 2004 issue of the Microsoft Architecture Journal.

A kernel of software engineering practices(1 min read)

Ivar Jacobson has written some recent columns for Dr Dobb's Journal about the similarities between different development methodologies, and specifically the difference between processes and individual practices.

The thread has picked up and gain some momentum through columns by other well known industry figures such as Scott Ambler:

A key part of Ivar's proposal is that what's really important is not so much the overall method but the individual practices.

This is similar to Steve McConnell's analysis,  in Code Complete Second Edition, of the improved defect removal rates of methodologies such as Extreme Programming, which are really just the expected effect of the combined individual practices.

Ivar also talks about a "kernel" of practices -- activity and work patten spaces (groupings) and "alphas" (prototypical deliverables). Without going through the detail of EssUP (Ivar's lightweight method based on this), the kernel consists of the following:

Process Area Activity Spaces
(Things to do)
(Things to produce)
Competencies Pattern Spaces
  • Understand the Need
  • Ensure Stakeholder Satisfaction
  • Accept the System
  • Opportunity
  • Customer Representative
  • Specify the System
  • Shape the System
  • Implement Software
  • Test the System
  • Release the System
  • Specified System
  • Implemented System
  • Executable System
    • Test
  • Analyst
  • Developer
  • Tester
  • Establish Project
  • Steer Project
  • Support Team
  • Conclude Project
  • Team
  • Backlog
    • Task
    • Defect
    • Change
  • Project
    • Risk
  • Way of Working
  • Project Lead
  • Collaboration
  • Control
    • Feedback
    • Lifecycle
    • Measurement
    • Planning
  • Organisation


Different processes, e.g. EssUP, Scrum, MSF, etc, can then be mapped to this kernel of concepts.


Joined Readify(1 min read)

I joined Readify this week.
Readify are a specialist Microsoft.NET consulting firm and have been at the forefront of Microsoft technology since I did training with them in December 2001, on .NET 1.0 beta.  They have developed their reputation as experts because they strongly support professional development of their staff, allowing them to skill up on new technologies "ahead of the game".

Work around for deployment of MOSS site with variations(4 min read)

One way to deploy MOSS (or SharePoint) sites is via stsadm export/import. There are, however, a few known problems, for example items hidden in navigation reappear and the first time you deploy your custom master pages are not applied. Fixes are possible; manually re-hide the items, and deploying a second (or more) time resolves the master page issue.

(Aside: I suspect the master page issue is a dependency problem -- during the deployment it tries to set the master page before it has been deployed, i.e. before it exists, and fails. The dependency is then resolved if you deploy again, as this time the master page does exist.)

However -- running the deployment (stsadm -o import) twice causes issues if you have variations (multilingual) enabled for your site. We found this out the hard way trying to deploy a large multilingual site into our test environment. When you try to access the site after the second deployment, you get the following nasty error (you need to turn off friendly errors and enable debugging, etc to troubleshoot):

Source Error:
Line 47:         private string GetRedirectTargetUrl()
Line 48:         {
Line 49:             ReadOnlyCollection<VariationLabel> spawnedLabels = Variations.Current.UserAccessibleLabels;
Line 50:             if (spawnedLabels.Count > 0)
Line 51:             {

Source File: c:\Program Files\Common Files\Microsoft Shared\web server extensions\12\TEMPLATE\CONTROLTEMPLATES\VariationsRootLanding.ascx    Line: 49

Stack Trace:
[NullReferenceException: Object reference not set to an instance of an object.]
   Microsoft.SharePoint.Publishing.Variations.InitializeUserAccessibleLabels() +199
   Microsoft.SharePoint.Publishing.Variations.get_UserAccessibleLabels() +33
   ASP._controltemplates_variationsrootlanding_ascx.GetRedirectTargetUrl() +44
   ASP._controltemplates_variationsrootlanding_ascx.OnLoad(EventArgs e) +18
   System.Web.UI.Control.LoadRecursive() +47
   System.Web.UI.Control.LoadRecursive() +131
   System.Web.UI.Page.ProcessRequestMain(Boolean includeStagesBeforeAsyncPoint, Boolean includeStagesAfterAsyncPoint) +1061

Even worse, some of the administration pages also break, for example trying to access /_Layouts/sitemanager.aspx results in the following error:

Object reference not set to an instance of an object.   at Microsoft.SharePoint.Publishing.Internal.VariationsPublishingOperationValidator.EstablishLabels()
   at Microsoft.SharePoint.Publishing.Internal.VariationsPublishingOperationValidator.Examine()
   at Microsoft.SharePoint.Publishing.Internal.WebControls.SmtWebEcbMenu.<>c__DisplayClass5.<setupTypeSpecificMenu>b__0()

The site itself should work if you manually go direct to one of the individual language sites, e.g. /en (or whatever your variations are). You can also still access /_layouts/settings.aspx, and if you look at the variation labels setup you will see that all of the variations are appearing twice!

If you deploy a third time, say a new build from the development team, then you will find that all the variation labels are now appearing three times!

The problem has been communicated to Microsoft, and they are working on a hotfix, but in the meanwhile poking around in the SharePoint content database we came up with the following SQL workaround.

Note: This is not complete; you will need to execute each statement and update the GUIDs into the next. It's safer to check it as you go rather than just start deleting parts of your database.

-- Select the target content database
use xxxxxxxx

-- Get Id of top level web
select top 100 Id, *
from Webs
where ParentWebId is null

-- Get tp_ID of the 'Variation Labels' list for that web
select top 100 tp_ID, *
from AllLists
where tp_WebId = '[Id of top level web]'
and tp_Title = 'Variation Labels'

-- Check the data items in that list.
select top 100 *
from AllUserData
where tp_ListId = '[tp_ID of variation labels list]'

-- Remove the duplicate labels (created after first import)
select * -- delete
from AllUserData
where tp_ListId = '[tp_ID of variation labels list]'
and tp_Created > '[some date/time after first deployment]'

After you figure out the GUIDs, just run the delete after every time you do a deployment (presuming you haven't added any new items).


A while later we discovered also that there were similar problems with duplicate cache profiles and content reports. The extra items can be deleted, but the report filters still don't seem to work. The investigations are continuing, but at least we can deploy now.

To see the other duplications after import, use the following SQL:

-- The same applies to caching and reporting setup
select *
from AllUserData
where tp_ListId in
  select tp_ID
  from AllLists
  where tp_WebId = '[Id of top level web]'
  and (tp_Title = 'Cache Profiles'
       or tp_Title = 'Content and Structure Reports')

Dependency injection via System.ComponentModel(1 min read)

In reference to a recent post on Matthew's blog (

(Graeme [Strange] suggested I catch up with the Readify blogs, so I've been reading recent posts.)

Note that the .NET Framework already includes a complete implementation of a dependency injection framework in the System.ComponentModel namespace.

It allows you to inject components which implement an interface into a service locator at runtime. Service consumers are then coded to search for the components they want via the public interface. All the plumbing handling service registration, etc, is handled in the .NET Framework.

The following post by Daniel Cazzulino has more information and gives some examples.

Mitch Denny has also previously posted on this.