When we looked at implementing the mechanism which would only extract new content from an inbound email, we found it surprising that there was no official standard for demarcating the beginning and end of an email in an email thread. We took a look at a few mail clients and discovered that Microsoft Outlook is capable of dealing with this problem. If you use one of newer versions of Microsoft Outlook, you’ll notice that the client is capable of detecting the boundaries between emails. Take a look at the screenshot below:

Notice how Outlook has detected the boundaries between each email. Each email has a gradient which assists you to navigate the thread, furthermore, if you hover over a specific email, you can jump to the next/previous email in the thread relatively easily.

While there didn’t seem to be a standard way of achieving this, we managed to get a decent solution in place for our ticketing system. Since we were sending out the emails which customers would reply to, we could standardise the email content such that we could easily detect the boundary when a customer responded. This was not a full proof solution, so in the end, we implemented a heuristic algorithm that could deal with most of the common mail clients out there. Implementing this feature made it infinitely easier to manage conversations with customers. Obviously, we always kept keep the original email as customers would sometimes reply with changes to the original email content (such as answering questions inline).

Last year, we started using FogBugz as our general case and project management system. What we discovered was that FogBugz isn’t as smart as the system we developed in terms of dealing with email conversations. Outbound emails would not include the full email conversation and if you don’t use the web interface to respond, the boundary between the new content and email thread isn’t detected at all. This usually leads to a very cluttered case view where you need to scroll over copious amounts of duplicate text.

To deal with this problem, I implemented a very simple JavaScript customisation which scans over the content in a case and hides any email text which is superfluous. You always have the capability to toggle the content if you do need to inspect it. I’ve included the code for the customisation below. We use Microsoft Outlook (and most of our clients do as well), so the solution works well for us. The code simply scans email for the ‘From: ..’ and splits the email there. It’s not rocket science.

$(function(){
    $('.emailBody').each(function(index, element){
        var body = $(element);
        var edgeIndex = body.html().indexOf('<br>\nFrom: ');
        if (edgeIndex == -1){
        	return;
        }
        var mainBody = body.html().substring(0, edgeIndex);
        var quotedBody = body.html().substring(edgeIndex);
        body.html(mainBody);
        body.append('<div class="showQuote" style="padding-top:5px"><a href="javascript:void(0);" class="dotted" onclick="$(this).parent().parent().find(\'.emailThreadBody\').toggle();">- show quoted text -</a></div>');
        body.append('<div class="emailThreadBody" style="display:none;"></div>');
        body.find('.emailThreadBody').html(quotedBody);
    });
});

Hope this helps. Hopefully, this issue is addressed in the next major version of FogBugz.

Cheers,
Rohland

The notification has all the information you need, however, it’s pretty hard to pick up the message someone may have included. I’m not a fan of plain text emails. When you start receiving a number of these notifications every day, it gets a bit annoying trying to scroll and find the meat of the notification. On Saturday I spent a few hours developing a plugin for Outlook 2010 that could assist with the issue. While this was not my only option (I could have developed a FogBugz plugin), I was intrigued to see if it was indeed possible to update the format of a message in Outlook. As it turns out it’s pretty easy.

This is the result:

I’m no designer (and Outlook’s HTML support is crap) but I’m relatively happy with what I was able to achieve in a short time frame. The plugin will update the email’s format as you open the email so basically, you never have to deal with the plain text version outlined in the first screenshot. Obviously, the downside to this approach is that notifications received on your phone won’t render in the format above (unless you are using Exchange or similar and have opened the email at least once in Outlook).

Other features I was able to add relatively easily included setting the priority flag on the email depending on the priority of the case. If the case is really urgent (priority 1 or 2), the priority flag is set appropriately.

If for some reason the parsing fails, the default email format is kept.

I’ve included the source code as an attachment of this post. Feel free to customise it for your needs. It should be relatively easy to update the template as it is bound to a model which is instantiated as a result of parsing the plain text email.

Hope this is useful.

Rohland

I’ve given this quite a bit of thought lately as we were in the process of migrating many of our systems to a new hosting provider. There are two main areas you need to focus on in minimising downtime for your clients:

• Time required to take the site down, backup, move and restore everything to the new server/s.
• The DNS record update.

The second item on this list is the major issue. You have little control over the amount of time your DNS update is going to take to propagate to your clients due to DNS record caching. Reducing the TTL is not a full-proof solution since many ISPs won’t obey unusually low TTL settings that you may configure. People have come up with various strategies for dealing with the issue such as implementing a temporary sub-domain while the DNS record update slowly propagates around the globe. Either of the options above may be your best bet in many circumstances, however, if you are making use of a load balancer or proxy (such as Nginx) migrating your site is less of an issue.

Before migrating to our new service provider, we were not making use of a load balancer such as Nginx/HAProxy, however, we had one setup at our new hosting centre (we went with Nginx) before we began the migration. Whilst the rationale for implementing Nginx was more out of the need to create a resilient hosting infrastructure for our clients, we also gained the ability to have more control over where our content is served from.

For those of you not familiar with the concept of a load balancer in the web context, it simply allows you to proxy requests through one endpoint to a dynamic number of back-end web servers. In the Nginx context, the back-end servers are configured as upstream servers. When an HTTP request is received, Nginx forwards the request to one of the back-end webservers. For each successive request, a round robin balancing algorithm is employed to fairly distribute the load. You can control the weighting of each upstream server to deal with a mismatch in server capabilities (think of 3 webservers where 1 is far more capable than the others due to better hardware). While Nginx sufficiently handles balancing in our case, HAProxy does have far more capabilities in this area.

Back to the DNS update issue (if the solution hasn’t become apparent yet, it will now). In our new environment, we configured our Nginx load balancer to point to all our existing webservers (i.e. not our new webservers). Once we completed the configuration of Nginx to do this, we updated all of our DNS settings. We then waited a few days. As you can imagine, over the course of time, each site began resolving to our new hosting provider but users experienced no downtime since Nginx was simply proxying the updated requests to the original servers. This meant that clients who had not yet received the updated DNS record were hitting the original servers, while clients that did receive the DNS update we also doing so but through Nginx at our new hosting provider. Once we were comfortable that everyone was hitting the various sites through our new setup we simply turned everything off and performed the real migration (i.e. physically move the databases etc. across).

Given this approach we minimised downtime for our clients. The 2-3 hours for the physical migration of databases and systems was acceptable to our clients, 2-3 days for DNS resolution was not. This solution mitigated days of potential downtime and worked well for us. The only real downsides to the approach was that our sites operated marginally slower (due to added latency between new and old host) and that we had to pay for bandwidth twice during the transition period. Both of these issues were tenable given the alternatives.

That’s it basically. I have documented the steps below for anyone who’s interested.

Cheers,
Rohland

Setup

Migration

Notes:

I want to be as objective as possible about my thoughts so as to add value to the discussion, but I guess I need to confess that my development experience is heavily weighted to the .NET platform. Over the years I’ve developed web, mobile and desktop applications using various languages, platforms and frameworks. That said, by far, I am most proficient in C#.

Firstly, I think it is important to note that it is somewhat difficult to accurately compare development contexts. It’s easy to confuse platforms, frameworks and languages. I once overlooked a developer typing this into Google:

Huh?

What makes Ruby on Rails so popular? Can we attribute its success to the language (Ruby) or the framework (Rails) or both? Some people may say that what makes developing using Rails so awesome is Ruby itself. Others may say it’s the framework, in which case the same developers could be as efficient on other similar frameworks such as CakePHP. If I had to venture a guess, I think that most experienced developers would go with option 3. It’s the entire ecosystem that makes Ruby and Rails so popular, as much as it’s the .NET ecosystem that makes ASP .NET a popular option as well. This makes it difficult to compare aspects of each.

I have never had the opportunity to develop an application using Ruby on Rails but I think I have enough experience on various other web platforms to raise the following point. No single language or framework defines a developer, especially a web developer. Right now, most of the applications I develop are web applications and this means I need to be fairly proficient at a number of languages, not just C# ( HTML/XHTML, CSS, JavaScript and SQL to name a few). When it comes to assessing efficiency of developing on a platform, we need to address all of these aspects. Sure, Rails addresses the SQL aspect (Active Record) right off the bat, but how does a Rails developer approach HTML, CSS and JavaScript development? As web developers, we spend a lot time in our server side language of choice, developing code to dynamically output HTML. That said, a lot of time is also spent on the client side as well – designing, developing and debugging JavaScript. How does the Rails environment stack up in this department? We make use of Spark as our view engine on MVC projects, and I guess Rails developers use something as slick (or better?). I’m not saying Visual Studio offers a better story for developers, I’m just interested to hear more about the Rails context. From a server side perspective, what is the debugging experience like in Rails? I’ve used Eclipse and a few other popular IDE’s and I’m yet to find one that matches Visual Studio’s debugging capabilities. Within a minute, a developer can write some code, set a breakpoint and have the breakpoint hit within seconds. No drama. The real point I am trying to make is that there is far more to just the server side language, or the framework that impacts on the efficiency of a developer in the web context. There are a lot of other factors which include the IDE, view engine and development web server.

I mentioned earlier that I haven’t ever had the opportunity to develop a Ruby on Rails application. That said, I have started learning Ruby and have recently developed an application that routinely synchronises our Basecamp data with a local SQL Server database. I specifically wanted to learn Ruby out of the Rails context first. I was delighted that within a relatively short amount of time I had some functional code. It bodes well for my continued personal investment in Ruby. I took a crack at developing my Ruby application using NetBeans on Windows. While I enjoyed developing the code (and learning more about chunky bacon), I really didn’t enjoy the environment. Debugging was a pain in the ass and I resorted to debugging by logging. I hate this approach. I’m not sure if my experience is unique, and would really appreciate feedback from seasoned Ruby/Rails developers on this.

One of the topics that constantly repeats itself in these types of conversations is that .NET developers are stuck. They aren’t good at venturing out of their comfort zone and learning about new languages on other platforms. While this is a gross generalisation, I fear that the recent converts to Ruby from C# are right (for the most part). I think familiarity plays a key role in this and the problem does not only apply to developers using .NET. In the book The Pragmatic Programmer, Hunt and Thomas recommend that a developer should strive to learn a new language every year. I must say that when I read this, I was astounded. Every year? Thats crazy! Then I realised that not only is it possible, but they are right. You see, developing on a single platform using the same language and framework, year in and year out has some advantages, but in general, your solutions to problems tend to take the general form of your environment. My recent foray into Ruby has proved this. Your mind becomes boxed into approaching problems in a single way where there may be another number of better solutions that expose themselves wonderfully when you are forced into a different pattern of programming. All in all, I would say that even though I haven’t been using Ruby for long, I’m a better C# developer for it. Note, that I am not suggesting that Ruby itself was the reason, you could replace Ruby with Python in the paragraph above and I believe the same would hold true.

When it comes to comparing .NET (and Microsoft solutions generally) to alternative free and open source solutions, cost and licensing are often cited as reasons to migrate away from the Microsoft platform. This seems to be an important part of the discussion. The argument that always seems to be tossed around is that as a startup, you don’t want to have sink your limited cash into technologies when the alternatives are free. I think this argument is flawed for a few reasons. If you have no experience using the alternative language, framework and platform then the comparison between cost only makes sense if your time is free. Lets face it, in the startup world, your time is not free. Whether being first to market is important or the fact that you only have a small window of opportunity where you can sustain yourself in the back of your garage, you will want to focus on getting your application deployed as soon as possible. Having to sit and learn something new and foreign when you should be focusing on building your app seems to be a weird approach to me, especially considering the factors described above. Even if you could get up to speed with the new language/framework/platform relatively quickly, once you have your application up and running for the world to see and use, you will have no experience dealing with runtime operational issues that usually crop up as people start using your app. Even when you have experience on certain platform, dealing with edge case operational issues can be tricky. In an ideal world, time wouldn’t be a factor. You could perform a systematic analysis on all languages, frameworks and platforms and assess the pros and cons of each. Unfortunately, I doubt anyone has the luxury of doing this.

So given that it makes sense to build your app using technologies familiar to you, what are you in for? Microsoft haters will most certainly start quoting licensing costs for SQL Server Enterprise Edition, Windows Server Enterprise Edition and how the costs will sink you in a month (or less). Again, I think one needs to look at licensing objectively. I just deployed an environment with 4 servers.

• 1 x load balancer running Nginx on Ubuntu
• 2 x web servers running Windows Server 2008 Web Edition
• 1 x database server running Windows Server 2008 Web Edition and SQL Server 2008 Web Edition

In terms of costing for bandwidth, hardware, offsite backup etc., the licensing costs associated with the Microsoft operating systems and servers accounted for just 6% of the monthly cost. I would hardly call that prohibitive. Sure, if I had to use the Enterprise (or even Standard edition) versions of the software, the costs increase quite dramatically. That said, I don’t see why a web startup would require these versions. In any event, if you want to compare apples with apples, then one should consider that the enterprise version of MySQL is not free. At this point, NoSQL fans will probably be butting their heads against a wall muttering that neither SQL Server or MySQL are good options. That’s fine. Use what works. The likes of MongoDB, CouchDB and RavenDB are available on the Windows platform (the latter developed in C# exclusively for the platform).

What about Visual Studio? Isn’t it quite expensive? Well, unfortunately, yes it is. That said, I think the one thing people don’t mention when discussing the cost of Visual Studio is what you are actually paying for. Have a look here. The Professional Edition with MSDN Essntials ($799) unlocks the following software for you:

• Visual Studio 2010 Professional
• Windows 7 *
• Windows Server 2008 *
• SQL Server 2008 *

* Per-user license allows unlimited installations and use for designing, developing, testing, and demonstrating applications.

So for essentially $800, you should be sorted for all the development software you will need to develop, test and demonstrate your application. It’s not free, but the deal isn’t too bad either.

This post is getting a bit long so I’m going to end here by saying this. While I’m a proficient C# developer, there is no reason why I should not dedicate time to learning about alternative languages, frameworks and platforms. It’s only going to make me a better developer, whether I stick to the Microsoft platform or not.

Both the website and mobi site were developed using Microsoft’s ASP .NET MVC 2.0 framework with some slight modifications to the vanilla setup. We chose to use Spark as our view engine. Spark’s syntax is declarative and resembles HTML which enables us to integrate code seamlessly (i.e. our views don’t evolve into spaghetti code). This is not the sole advantage of using Spark, I would recommend taking a read through the documentation to realise the more important benefits. This is not the first project we’ve integrated Spark with, and we continue to enjoy working with it.

In terms of client side scripting, we used jQuery as our JavaScript library. Combres (an open source project hosted on Codeplex) was implemented at the backend to ensure that resources such as JavaScript and CSS were minified and compressed before being served to a customer’s browser. Furthermore, Combres enables us to easily update our JavaScript/CSS references which ensures that the latest version of the relevant resources are always loaded.

For the mobi site, we stuck with MVC but ensured that the markup produced by the server was XHTML-MP compliant. Given the nature of the mobile landscape, we were required to support a large number of internet enabled devices ranging from smart phones (such as the iPhone) to the hugely popular Samsung E250. For Mobile Researcher we use a library called Device Atlas which enables us to detect the type of device accessing the site and provide information regarding key capabilities. Given our experience with the product we used the same library on the Debonair’s mobi site. Images are automatically scaled and cached for devices accessing the site which ensures the site’s look and feel remains consistent no matter what resolution the relevant device sports. In time, we may begin enchancing the site for specific devices such as iPhones and Blackberrys.

For persistence we chose SQL Server 2008 R2 Web Edition. We have extensive experience working with both Microsoft SQL Server and MySql, however, we wanted to utilise Windows Workflow 4.0 as part of the solution and we didn’t have time to look at writing a custom MySql persistence service for the workflow engine. In any event, our selected ORM (LLBLGEN) enables us to target any number of database technologies so theoretically, we could switch over to MySql in the long term without too much work. From a code perspective, we implemented the repository pattern using custom LLBLGEN templates. At the repository level, queries were developed using LLBLGEN’s LINQ engine.

Windows Workflow 4.0 was used to handle longer running processes such as those invoked when placing an order. Once an order is validated, the order is serialised into XML and posted to a third party POS gateway which performs further validation and propagates the order down to the relevant store. There are number of failure points involved in this process hence the use of Windows Workflow. If the order is not successful (whether it reached the third party gateway or not) an SMS is sent to the relevant customer informing them of the failure. As you can imagine, there are a number of issues that could cause this to happen including network connectivity failures to the the third party gateway, connectivity problems between the stores and the gateway etc. We wrote a custom Workflow Application Manager that manages persistence and execution of Workflows which means the system is resilient against system reboots etc.

A Windows Service was developed to host the workflow runtime and provides the host for workflow execution. Besides order processing, the service handles menu synchronisation, store connectivity tracking and communication (email/SMS) services. To facilitate communication between the web and mobi-site, we used NServiceBus which leverages MSMQ. NServiceBus enables us to deliver messages to the Windows Service in a transactional context which is obviously critical.

As far as unit testing goes, we used a number of frameworks and libraries to facilitate the unit testing process. For the core testing framework, we used NUnit. For our mocking library we chose Moq. Moq simplifies the mocking process considerably as it exposes a fluent API. If you haven’t heard of Moq I seriously recommend checking it out.

Right now both sites are humming away on IIS 7.5. There is a lot more to come with a number of key features still in development/testing, the main being the ability to pay for an order using your credit card. All in all, the
implementation process has has been an exciting experience which has allowed us to leverage a number of new and useful technologies. Without resorting to butchering the idiom ‘the proof is in the pudding’, please think about placing your next order for a Pizza using one of the sites mentioned – we would really appreciate your feedback.

If you have any questions, comments or suggestions please free to give me a shout.

Cheers,
Rohland

If I created a new Workflow 4.0 project in Visual Studio 2010, everything worked as it should. However, if I integrated Workflow 4.0 with an existing project I ran into problems. After numerous Google/Bing searches I found a few examples of forum/stackoverflow posts about the problem but usually in the VS2010 Beta context.

It tuned out that the problem in my case is that I had two projects in my solution where the project files (*.csproj) were in the same directory. VS2010 did not like that for some reason. After moving the two projects into separate folders, everything worked! Absolutely bizarre.

If you are interested, the reason I had two project files in a single directory was because it’s the default configuration when using LLBLGEN (adapter mode). It generates two projects, one database specific and the other generic. It is possible to get LLBLGEN to generate the projects in separate folders, you can find the instructions here.

Feel free to play the sad trombone if you wasted as much time as I did.

Cheers,
Roh

Near the end of last year I started looking at offsite backup options that didn’t require user intervention and was very excited to discover the svnsync command. The benefit of svnsync is that only new revisions are mirrored and not the full repository each time. This is absolutely critical if you have a repository that is quite active. Needless to say, I decided to forge ahead and try my hand at implementing automated scripts to take care of backing up our repositories online utilising the svnsync tool. As a reference I have posted the setup process here.

Its important to note that this guide assumes you are working in a Windows environment and that you have access to a server offsite. I have referenced a few articles and other blog posts I discovered along the way to help you if you are working in a Linux environment.

Hope you found this useful. I might follow this post up with another blog entry on steps I took to setup an automated script to email me when a repository on the host machine is missing its mirrored counterpart. This is really helpful to detect cases where a repository was setup locally but not configured for synchronisation, furthermore the ability to automatically generate the relevant scripts is quite useful

Rohland

References:
http://journal.paul.querna.org/articles/2006/09/14/using-svnsync/
http://www.rosshawkins.net/archive/2009/04/27/using-svnsync-properwith-visualsvn.aspx
http://devlicious.com/blogs/christopher_bennage/archive/2009/03/11/mirroring-subversion-from-windows.aspx

It was the start of 2009, and I was investigating ORM tools for a new project we were working on at Clyral. We had been using Linq 2 SQL as our core database access layer for some time but felt we had outgrown it and were looking for something a bit more powerful and flexible. It didn’t take long for us to discover LLBLGEN. Whilst not the most intuitive acronym for an O/R mapping framework, LLBLGEN (Lower Level Business logic Layer Generator) impressed the team from the outset. After downloading the demo version and playing around with it on a test project we committed to purchasing it and since then haven’t looked back.

We started off using the Self Servicing model of the framework as it was earmarked for beginners, in time though, we began to see that we would get more mileage using the adapter model and began using this model as the defacto standard for projects. It was at this point we began looking at ways to implement the repository pattern which simplifies the testing process and ensures the implementation (which is often technology specific) does not get mangled with the domain model. To achieve this we needed every entity to implement an interface (or contract if you will). The problem with this of course, is that in C# generic variance is not supported. This posed a bit of a problem because we still wanted the full representation of a given entity graph to be available using our defined interfaces. To get around this, we needed to update the LLBLGEN templates to allow us to inject our own custom implementation of collections which would match our interface definitions. I have provided a few example snippets to illustrate what I am talking about. Essentially we added properties which took a Todos collection (property of a TodoList entity) such as defined below:

public virtual EntityCollection<TodoEntity> Todos
{
	get
	{
		if(_todos==null)
		{
			_todos = new EntityCollection<TodoEntity>(EntityFactoryCache2.GetEntityFactory(typeof(TodoEntityFactory)));
			_todos.SetContainingEntityInfo(this, "Todolists");
		}
		return _todos;
	}
}

and added the code below to support out interface definition:

public EntityList<ITodoEntity, TodoEntity>  TodosCollection
{
	get
	{
		if (_TodosCollection == null)
		{
			_TodosCollection = new EntityList<ITodoEntity, TodoEntity>(this.Todos);
		}
		return _TodosCollection;
	}
}

private EntityList<ITodoEntity, TodoEntity>  _TodosCollection;

where “EntityList” is a custom wrapper we wrote to get around the generic variance issue (note that EntityList understands that a TodoEntity is an implementation of ITodoEntity). This allowed us to define our entity contracts as such:

    /// <summary>
    /// Interface for the entity 'TodoList'.
    /// </summary>
	public partial interface ITodoListEntity
	{
		EntityList<ITodoEntity, TodoEntity>  TodosCollection {get;}		

		System.Int32 Id {get;set;}
		System.String Title {get;set;}
		System.String Description {get;set;}
		System.Int32 ProjectId {get;set;}
		System.Int16 Position {get;set;}
		System.Boolean Billable {get;set;}
		System.DateTime CreatedOn {get;set;}
		System.DateTime ModifiedOn {get;set;}
		System.String CreatedBy {get;set;}
		System.String ModifiedBy {get;set;}
		System.Guid CreatedUserId {get;set;}
		System.Guid ModifiedUserId {get;set;}
	}

As you can see, a standard was implemented where the original list’s name was simply extended with the word “Collection”. After modifying the adapter’s templates and generating our templates to create the entity contracts, everything fell into place and we had our repository pattern implemented. Our repository definitions ensured that only interfaces were passed round (of course implemented using LLBLGEN’s entities) which in turn ensured that our UI (or business logic) knew nothing about the underlying implementation. One benefit of doing this is that the chaps working on the UI never had to deal with the copious number of properties and methods that hang off an LLBLGEN entity by default. Of course, these properties and methods are useful in some cases and can still be used within the repository itself.

I have attached a zip file to this post with the implementation of the EntityList class as well as the templates that we modified and added to make this all happen. Let me know what you think, any comments or suggestions regarding the implementation are certainly welcome!

Rohland

Templates and supporting files

The application I was building was developed on ASP .NET MVC (C#) so naturally I was looking for some C# code I could use to implement the difference algorithm. In searching, I could not find any libraries that were worth implementing. I did come across one or two command line utilities but nothing spectacular. I widened my search to other languages and came across a neat implementation in Ruby. The algorithm was developed by Nathan Herald who generously made the code available to everyone via the common MIT license.

So, I had the algorithm I was looking for, but I didn’t speak Ruby! This was an excellent opportunity to roll up my sleeves and learn some Ruby so I fired up my browser, downloaded the Windows one-click installer and got a simple environment up and running. After toying with code for a bit, scratching my head at one or two alien Ruby constructs I got the gist of how things worked. I fired up Visual Studio, created a new project and began the process of porting the algorithm. I must admit that the process was relatively painless and I got something working in a few hours. It took about another hour or two to iron out some bugs I picked up but essentially, in a relatively short space of time, I had the C# diff library that I was originally looking for! Below is a demo of how it is used, followed by one or two screenshots demonstrating the functionality when rendered to your browser.

            string oldText = @"<p>This is some sample text to demonstrate the capability of the <strong>HTML diff tool</strong>.</p>
                                <p>It is based on the Ruby implementation found <a href='http://github.com/myobie/htmldiff'>here</a>. Note how the link has no tooltip</p>
                                <table cellpadding='0' cellspacing='0'>
                                <tr><td>Some sample text</td><td>Some sample value</td></tr>
                                <tr><td>Data 1 (this row will be removed)</td><td>Data 2</td></tr>
                                </table>";

            string newText = @"<p>This is some sample text to demonstrate the awesome capabilities of the <strong>HTML diff tool</strong>.</p><br/><br/>Extra spacing here that was not here before.
                                <p>It is based on the Ruby implementation found <a title='Cool tooltip' href='http://github.com/myobie/htmldiff'>here</a>. Note how the link has a tooltip now and the HTML diff algorithm has preserved formatting.</p>
                                <table cellpadding='0' cellspacing='0'>
                                <tr><td>Some sample <strong>bold text</strong></td><td>Some sample value</td></tr>
                                </table>";

            HtmlDiff diffHelper = new HtmlDiff(oldText, newText);
            string diffOutput = diffHelper.Build();

Using the sample web application provided with the project in Codeplex, the following is rendered based on the code above:

Old HTML

Updated HTML

HTML diff output

You can see that the algorithm as originally developed takes care of the nasty HTML parsing to figure out how to highlight the differences. The changes are marked up using “ins” and “del” tags. You can easily style these tags as I have done. The CSS below is responsible for rendering the differences as per the example.

ins {
	background-color: #cfc;
	text-decoration: none;
}

del {
	color: #999;
	background-color:#FEC8C8;
}

I hope you find the library useful. I wish I had more time to add tests and more documentation to the Codeplex project, but for now I think the implementation is reasonably solid and easy to follow. If you spot any bugs, let me know and I’ll try and attend to them. Given that I am not responsible for the original implementation as developed in Ruby, it might be a bit tricky to solve some of the fundamental issues with the algorithm but I will certainly have a crack at it since I have quite a good understanding of how it works after porting it.

Link to C# implementation: http://htmldiff.codeplex.com
Link to Ruby implementation: http://github.com/myobie/htmldiff

I am very grateful for the service made available via the dotnet.org.za portal. A year ago it allowed me to get up and running with my blog relatively quickly. To the administrators of the portal – thank you!

In terms of moving forward, I was not sure what the correct procedure for moving my existing blog away from dotnet.org.za was, so I ended up implementing a simple script to redirect to my new domain. Hopefully, I will be able to organise a mechanism whereby future posts here reflect in the dotnet.org.za main feed. If not, then I guess that is the penalty for moving my blog.

Hopefully you subscribe to the RSS feed available here, or at the very least, check back periodically for new content. Please let me know if spot any issues.

If you have landed here after clicking a link related to one of my older blog posts, simply use the search feature available in the side bar to locate the content you were originally hoping to review.

Cheers,
Rohland