SharePoint 2010 logging levels(3 min read)

According to MSDN "in Microsoft SharePoint Foundation 2010 the preferred method of writing to the Trace Logs is to use the SPDiagnosticsServiceBase class" (

MSDN also provides some guidance on the trace and event log severity levels to use (, however the WriteEvent() and WriteTrace() methods use slightly different enums; the diagnostics logging configuration in Central Administration is slightly different again, and then you have a third set of values accessed by the PowerShell command Get-SPLogEvent.

The table below shows the mapping of levels from these different sources.

Despite the complicated mapping, in general I think things go in the right direction with events writing to the event log and trace log at the same time, and having a high trace level. The distinction between event logging and trace information is also good, with independently set thresholds.

EventSeverity EventLogEntryType TraceSeverity ULSTraceLevel ULSLogFileProcessor
None = 0 None = 0 0 (None) Unassigned = 0
ErrorServiceUnavailable = 10 Error 1 Critical = 1 (or ErrorCritical)
ErrorSecurityBreach = 20
ErrorCritical = 30
Error = 40
Exception = 4
Assert = 6
Warning = 50 Warning 8 Warning = 8
FailureAudit = 60
Unexpected = 10 Unexpected = 10 Unexpected = 10
Monitorable = 15 Monitorable = 15 Monitorable = 15
SuccessAudit = 70 Information 18 Information = 18
Information = 80
Success = 90
Verbose = 100
High = 20 High = 20 High = 20
Medium = 50 Medium = 50 Medium = 50
Verbose = 100 Verbose = 100 Verbose = 100
VerboseEx = 200 VerboseEx = 200 VerboseEx = 200

Continue reading SharePoint 2010 logging levels(3 min read)

[Rant] Why are IM/presence networks still fragmented?(3 min read)

Email (well, the majority of it anyway) is one nice standardised SMTP network -- any mail server can send to any address, finding each other by the domain. To some degree client protocols are also standardised (IMAP or POP), and although there are exceptions (e.g. Exchange protocol) the servers and clients still generally support the standard protocols as well.

Instant messaging, presence, and related networks are, however, still fragmented.
Continue reading [Rant] Why are IM/presence networks still fragmented?(3 min read)

SharePoint 2010 design considerations(3 min read)

SharePoint 2010 introduces the ribbon bar as a central place for all the editing controls, that in earlier versions could be scattered across the page.

When designing custom master pages for SP 2010 you may want to visually integrate the ribbon bar into the design, as is done in the out-of-the box v4.master (wiki & workspaces) and nightandday.master (publishing portal) pages.

To do this, I have documented the size of the different elements, so they can be included in the design.
Continue reading SharePoint 2010 design considerations(3 min read)

Essential.Diagnostics library added to CodePlex(1 min read)

Essential.Diagnostics is a library of additional trace listeners and other bits for the .NET Framework System.Diagnostics trace logging.

It doesn’t change the way you write log statements (you still use TraceSource), but fits into the built-in extension points to add functionality (mostly additional trace listeners and filters).

From the project description:

“Essential.Diagnostics contains additional trace listeners, filters and utility classes for the .NET Framework System.Diagnostics trace logging. Included are colored console (that allows custom formats), SQL database (including a tool to create tables) and in-memory trace listeners, simple property and expression filters, activity and logical operation scopes, and configuration file monitoring.”

The intention is to round-out System.Diagnostics with additional capabilities so that it can be compared to alternative 3rd party logging systems (NLog, log4net, Common.Logging, and even Enterprise Library).

Note that the library is intentionally much lighter than Enterprise Library; rather than an overhaul of the logging mechanism itself the library is mainly meant to provide additional trace listeners.

I put the source code up a few days ago, but only recently finished the packaging scripts for the downloads.

With the recent release of NuPack NuGet, I have also spent an additional bit of time and set it up as a NuGet package.

Automatic assembly file version numbering in TFS 2010(3 min read)

A colleague, Richard Banks, has previously blogged on this topic (, using custom activities and modifying the build workflow.

However, I also like the approach taken by John Robbins  (

John's approach is done entirely within the build file, using some of the new features of MSBuild 4.0, and therefore has no dependencies except what is already on a TFS build server.

Based heavily on John's work, I've created my own build targets that are based on the same core features but tailored to the way I like to work.

The build number is still based on the TFS build number, however rather than a base year of 2001 I pass it in as a property. This avoids the problem that a build on 31 Dec 2012 could be number 1.0.51231.1, whereas the one on 1 Jan 2013 would be By setting the base year to the year your project starts you ensure your build numbers start low and increase.

(If you start reaching the end, after five years or so, you can always reset the base year after changing the minor version).

I also have an option to read the major and minor versions from the existing AssemblyInfo.cs file, rather than having them set in the build script, which I find a useful way to allow me to change the version number.

Like John's script, I only update AssemblyFileVersion, which can help in a multiple-project situation where there are version dependencies on strong names (such as in config files).

However, rather than a central shared version info file, I write the updated version number back into the projects AssemblyInfo.cs file.

The benefit of John's original approach is that you can have a separate project dependency that updates a central file for all builds, whereas with my approach you need to update each project's build (.csproj) file. On the other hand the negative with the original approach is that you need to change the structure of projects to point to the shared file, whereas I keep them self-contained with the original AssemblyInfo.cs file (similar to Richard's approach).

I only made changes to the C# project type, which is where I do most of my work, and so don't support all the project types that John's script does (VB.NET, C++, etc).

The only other output I have implemented is writing straight into a text file, which I find useful to copy to the output directory as a easy way to reference the build. This is particularly useful for web projects, where they are a directory full of .aspx files (and you can also hit the Version.txt file from a browser).

To use the script, include the TFSBuildNumber.targets file somewhere in your solution or project, then copy the example lines from Example.csproj to the .csproj files for projects you want to version.

To do this from within Visual Studio, first you need to right click and unload the project, then right click and open the file for editing. After pasting in the code, save and close the file, then reload the project.

The end of your .csproj file should look something like this (alter the path depending on where you placed the TFSBuildNumber.targets file):


  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Import Project="..\TFSBuildNumber.targets" />
  <Target Name="BeforeBuild" DependsOnTargets="GetMajorMinorFromCSharpAssemblyInfoFile;WriteProjectTextAssemblyVersionFile;UpdateCSharpAssemblyInfoFile">

One benefit of having the version numbers line up with the TFS build numbers is that given a particular DLL you can check the version number and then easily translate to the particular build it came from, e.g. (with a base year of 2010) the version number 1.0.924.5 comes from TFS build number 20100924.5.

If you want to use this in your project, download the TFSBuildNumber.targets file from the Essential Diagnostics project on CodePlex.

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

Content Deployment Bootcamp (Mark Rhodes)

Reasonable mix of slides and demos. Several of the slides had an interesting grab of quotes from the community on the new SP2010 content deployment -- most of them positive (or at least optimistic).

There was a brief mention of the problems with content deployment in MOSS2007 (particulary with variations), with the comment that despite initial issues MOSS2007 deployment actually got better with the various service packs and cumulative updates.

The demo was nothing special (it's relatively easy to get simple content deployment working in a demo/lab environment -- it was always real world deployment, with WAN issues, etc, that had problems).

SharePoint 2010 web part development (Ishai Sagi, Brian Farnhill)

The presentation was mostly demos (there were slides, but they weren't used much) -- which actually worked quite well. The two presenters worked well together and packed in a heap of demos -- an AJAX web part built from scratch, a Silverlight web part, how to upgrade web parts from 2007 including a demo of existing WSP's just working versus ones that need recompiling (or updating), plus a demo of the new developer dashboard and how you can use it to troubleshoot web part perfomance issues.

It was a lot of demo's they packed in and fairly informative. A good session overall.

Information Management with SharePoint 2010 (Rai Umar, Gayan Peiris)

A business-focussed session with a good overview of the information management aspects of SP 2010.

SP 2010 has expanded many of the record management features to be applicable anywhere you want in the system (not just a single record center). Another key component is the managed metadata service with hierarchical taxonomies.

There was a good slide with the positioning of different elements (MySites, digital asset management, etc) fit on a scale of managed taxonomies to open folksonomies and scope from team to enterprise-wise.

SharePoint 2010 Development - Business Connectivity Services (Adam Cogan)

The session title was not a good description of the content -- Adam went off on quite a tangent and a significant portion was spend on Facebook integration (I think this is just Adam doing his own thing -- something I have seen before).

Anyway, after a brief demo of BCS connecting to Adventure Works as a power user (including pulling the result into Outlook), the majority of the session was about integrating SharePoint + Facebook.

Admittedly one of the options for integrating with Facebook was via BCS, which may have been the point of the demo (not sure). In terms of other options given there was pulling from Facebook (via JS or API) or pushing to Facebook (via Workflow or Event Receiver).

It was suggested that the push model (e.g. Workflow) may actually be best for organisations that want to own their own data, plus push to multiple locations (SharePoint, Twitter, LinkedIn, etc), although the BCS option was the one demoed.

For the BCS option, the Facebook Development Kit (from Codeplex) was used to show how easy it is to integrate SharePoint + Facebook.

In Depth Architecture and Design Planning

Slides only presentation covering a wide range of architecture and planning. Started with an refreshing on MOSS 2007 capacity planning, then moved into SP 2010 considerations.

A brief mention of upgrade options, with in-place upgrade not recommended in most cases. (The database mount aka database attach approach was recommended as best practice; there are also many situations where in-place is not even directly possible, e.g. where hardware migration is needed.)

There was a discussion of disaster recovery solutions, mostly focussing on database mirroring. SP 2010 is failover aware, but using a SQL alias for your database is still a good idea for databases such as the config database.

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.