In this article I’m going to take a look at some of the top CMS platforms we’re working with, and the pros and cons they all bring.

The CMS platforms I’ll be comparing are:

• EPiServer CMS
• Sitecore
• Sitefinity
• Umbraco

I’ll start off by taking a look at each of the platforms and producing a summary for each one focusing on its benefits and features.

EPiServer CMS

An excellent enterprise-level CMS that focuses on robustness and simplicity to manage page level content, supported by their tag line: “Power through Simplicity”. It contains access control levels, user management, and business workflows to ensure that content is added and maintained in a controlled manner through its ability to closely integrate with Active Directory.

Its simplistic WYSIWYG interfaces allow administration from users with varying levels of technical ability. EPiServer contains some nice functionality to create visitor groups, meaning that you can segment and group content to specifically target certain visitors; out-of-the-box this includes geo-IP, visited pages and visitor groups.

EPiServer has a suite of add-ons which allow it to create a more integrated platform:

• Web Content Management (CMS)
• E-Commerce
• Social media and community (Relate+)
• Campaign and e-mail marketing
• Search-engine optimization (SEO)

Linking with Relate+, EPiServer can be configured to build a branded community; functionality includes forums, user groups and the ability for user-generated content to be implemented.

EPiServer can be extended to integrate with Microsoft Dynamics CRM or Salesforce allowing it to have seamless integration with lead management, client account history and contacts.

Sitecore

Sitecore is an enterprise-level CMS platform that has been developed over the past 10 years to become one of the industry leading CMS platforms. The CMS uses an easy to use WYSIWYG editor to create and manage content, this also features a Windows-like interface which makes working with the CMS that little bit easier.

Sitecore offers its fully integrated “Customer Engagement Platform” which allows seamless integration between its major components.

• Web Content Management (CMS)
• Customer Engagement Platform
• Digital Marketing System
• E-Commerce services
• Intranet Portal (Additional license required)
• Foundry Multisite Solution (additional license required)

The out-of-the-box functionality allows for full tracking and reporting on user behaviour, as well as close integration with the sales and marketing platforms, meaning that engagement automation of communications with customers across all channels can help maximise efficiency of moving prospects through the sales funnel.

The digital marketing platform helps to create an understanding of campaigns and site performance and helps you gain the insight needed to improve conversion rates and generate more qualified leads through web, email, mobile and social channels.

Sitefinity

The Sitefinity CMS has been developed by Telerik, a team responsible for some great Microsoft .net products and solutions such as RadControls. The core ethos of Telerik has always been to make software development easier and more enjoyable. Sitefinity uses .net standards such as MasterPages and Controls for template management all of which makes setting up the front end of the site is straight forward.

From an SEO perspective, Sitefinity has some simple yet effective ways of optimising a site from managing the URL structure, extension-less pages and meta information management. The URL routing and infrastructure is based on the Microsoft MVC engine.

Some of the enterprise features of Sitefinity comparable to the other platforms:

• Form builders
• Blogs
• Ecommerce
• Multi lingual
• Workflow management
• CMS Role management

Umbraco

Umbraco is a leading open-source CMS platform that has been developed using Microsoft .NET. The open-source licensing model means that the platform is supported by an active developer community who are constantly updating and adding to the main source code. Umbraco provides a full-featured web content management system that is easy to use, simple to customise, and robust enough to run the largest sites such as wired.co.uk and asp.net.

Umbraco focuses its offering on the ability to customise and extend its core platform. This functionality is realised through its easy to use APIs, ability to use commercial .NET controls, and support for DLR compatible languages; all of this means that the Umbraco solutions created are highly scalable but may require more investment to get the initial platform up and running.

In order to reduce the overhead of development there are already a large number of components such as galleries, calendars and back-office integration that can be added and customised to an Umbraco installation.

Feature comparison

To start off I did a simple check on our old favourite CMS compare tool CMS Matrix to see how the CMS platforms stack up against each other in terms of out-of-the-box or features from a standard install. CMS Matrix is a great tool that lists all the core features that are available across CMS platforms, and segments them into handy groupings: System Requirements, Security, Support, Ease of Use, Performance, Management, Interoperability, Flexibility, Built-in Applications and Commerce (Commerce is excluded on this post as all the platforms require an add on). The features are then evaluated and given a rating of Green (Fully available), Amber (Partial Feature or Add-On Required) and Red (Feature not available at all), below is a summary table of the ratings given for each of the platforms across the 126 possible features:

As you can see from the above table, the leader in terms of out-of-the-box core features is EpiServer CMS by just 2 features, closely followed by Sitecore and Sitefinity. However, if we look at the overall ability to offer the full range of CMS features is Sitecore which makes up its difference in base features with freely available add-ons.

So, looking at the stats it seems Sitecore gives the strongest platform for a full-featured CMS and for options in the future. It’s worth pointing out though, this is all only relevant if you need all of the features.

The Branded3 process is always to identify the objectives and requirements of a project and select the right tools for the job (including if a CMS is required!), so if you don’t need all of the features then it’s not worth investing in such an intense system.

The solution is found in a completely different world -  the world of economics – in the principle of 80-20 by Italian economist Vilfrodo Pareto.

To quote Wikipedia:

“The Pareto principle states that, for many events, roughly 80% of the effects come from 20% of the causes.”

This principle in the business world shows up in several different aspects:

80% of your profits come from 20% of your customers
80% of your complaints come from 20% of your customers80% of your profits come from 20% of the time you spend
80% of your sales come from 20% of your products80% of your sales are made by 20% of your sales staff

Therefore, many businesses have an easy access to the answer to making dramatic improvements in profitability, by focusing on the most effective areas and eliminating, ignoring, automating, delegating or re-training the rest, as appropriate.

Industry Applications

Whether knowingly or not, industries implement some variation of Pareto Principles for optimisation efforts. Some of the variation used in industries are Gini coefficient, Hoover index, Theil index, etc.

Microsoft noted that by fixing the top 20% of the most reported bugs, 80% of the errors and crashes would be eliminated. Any developers dream would to write a bug-less code, but in reality, this can’t happen.

To find out how much effort should be added to achieve desirable quality, we can refer to Pareto efficiency.

Looking at the Production-possibility frontier, shows how productive efficiency is a precondition for Pareto efficiency. Point A is not efficient in production because you can produce more of either one or both goods (Butter and Guns) without producing less of the other. Thus, moving from A to B, C or D enables you to make one person better off without making anyone else worse off (rise in Pareto efficiency).

This concept can be applied in various different aspects of software engineering, mainly:

• How much tolerance is allowed without affecting the quality or functionality of products
• How much efforts should be added to achieve desired quality
• Cost required to achieve desired results
• Value of risk involved in specific approach taken

Software testing

Software testing is an investigation conducted to provide stakeholders with information about the quality of the product or service under test. Software testing can also provide an objective and independent view of the software, to allow the business to appreciate and understand the risks of software implementation.

Test techniques include, but are not limited to, the process of executing a program or application with the intent of finding software bugs (errors or other defects).

There are various tools, techniques and methods available, not all are applicable, capable and feasible of achieving 100% of the desired quality, code testing, etc. So most of the time everyone ends up using a mix and match of various different tools and techniques. In the last decade or so, a tool set around web testing has been built and is constantly growing.

Nowadays, it is very hard to find a developer who has not written any unit test. To keep the article simple, I will write the approach but all the technology variants are available for all tools discussed.

• Unit testing : junit, nunit or a Microsoft test in visual studio. Code snippet to test a piece of code or discreet functionality.
• Selenium : Firefox browser based plugin and server to test the user actions and data flow. This records the user click actions and key entries to replicate the test. Limited to test the UI behaviour in web applications.
• WaitN : Automated html element testing tool for web applications. Handles popup, ajax and Java script calls. Works with various different browsers. Again limited to web applications.
• Rhino mocks : This is a mocking object framework for .net platform and used to test little under the skin functionality. This testing technique used to replicate the interactions of objects involved in use case functionality.
• Writing your own : You can write your own similar tests using HttpSimulator.

Automated testing

There are other commercial testing suits available and major software houses are using these suits. To achieve the functionality of a commercial testing suit, you can implement various techniques readily available separately.

I am going to use Team Foundation Server (TFS) and a .NET project to explain the approach.

• Enable TFS for continuous integration using CCC + nant or TFS build.
• Add TFS rule to run code analysis before check-in, thus improving quality of code.
• Create MS unit test or nunit test for all the code functionality unit tests.
• Record these unit tests as test work items in TFS
• Add check-in policy to run these unit tests, thus preventing any bug passing in build code.
• Set automated builds and deploy to a staging / testing server
• Run unit tests once the automated build is successful
• Update the test work items status after every build and record their status
• Send summary notifications for failed build and deployment status.

Each of these steps can be written more in depth, but I’ll include this in another post, and save 80% of my efforts for 20% of quality articles!

You can run things interactively using F# Interactive or you can compile something up and use it as a normal executable. It’s super-fast to prototype with, which is great when you’re just throwing ideas around the office like we often do at Branded3.

I thought I’d start simple and share a little script which I’ve used to grab the titles from websites and output the results to the screen:

open System
open System.IO
open System.Net
open System.Web
open System.Text.RegularExpressions

let http (url:string) =
   try
        let req    = WebRequest.Create(url)
        use resp   = req.GetResponse()
        use stream = resp.GetResponseStream()
        use reader = new StreamReader(stream)
        let html   = reader.ReadToEnd()
        html
    with
        | :? UriFormatException -> String.Empty
        | :? WebException       -> String.Empty

let title (html:string) =
    let r = new Regex("(<title[>])(.*){1}(<\/title>)")
    let m = r.Matches(html)
                |> Seq.cast
                |> Seq.map (fun(m:Match) -> m.Groups.[2].Value)
    match m with
        | _ when Seq.isEmpty(m) -> String.Empty
        | _                     -> Seq.head(m)

let websites = [ "http://www.branded3.com/";
                 "http://www.twitition.com/"; ]

websites |> List.iter (fun(u) -> printfn "%s" (title (http u)))

Now, you can’t tell me that doesn’t look pretty? You can see that we’ve got a function called http; a function called title; and a list of strings called websites. Both functions and values are set using the let keyword, and subsequent lines are indented to show where they belong. No extra curly braces here!

The last line is my favourite part. The websites value is piped through to List.iter which will iterate through each of the URLs in the list and run the supplied function on them. In this case, that supplied function is an anonymous function which takes in the URL and prints out the title.

The final output is a printed list of titles:

Branded3 is a leading SEO, Web Design & Development Agency
twitition  - sign petitions using twitter

Naturally you can expand this by adding functions for using text files to get the URLs or write the output. Or even new functions that take the URL and get the HTTP status code or website structure, then output each line to a CSV file. But I’ll save those functions for future posts…