Wednesday, December 30, 2015

Interactive Rebasing in Git

This post is a quick look at one of my favorite features in Git, interactive rebases.  I like this feature because it lets you do two conflicting things: make micro commits (like saving every couple of  minutes when editing a Word doc) so you can replay your work, and always go back to a working state of your code, and making clean, well worded, self contained commits to a project repo.  Interactive rebasing lets you squish your commits together when you are ready to share them.

Wednesday, December 23, 2015

A Look at Git Hashes

Git is a locally stored database with integrity guarantees. To get  a feel for how this works, this post takes a look at a very simple repository using the commands hash-object and cat-file. Although these are not commands you would normally use (they are among the "plumbing commands" that lie behind the "porcelain commands" like clone and commit), they are very helpful for inspecting the objects that a Git repository manages.

Wednesday, December 16, 2015

Looking at 'this' in JavaScript

JavaScript looks a lot like C#. But the internal plumping is utterly different. I've always found this somewhat befuddling. As a C# developer, you kind of think you know how things are working, but often you don't. Which makes figuring out what's happening when things are not working really challenging. I've just started reading a book in Kyle Simpson's (@getify) accurately titled series, You Don't Know JavaScript, a slim monograph on this & Object Prototypes, and things are kind of clearer. Kind of.

Wednesday, December 9, 2015

Node.js Development with Visual Studio Code

Last weekend I took my first steps in Node.js development, adding a small feature to a Hexo plugin. Hexo, as I blogged last week, is a static site generator written in Node.js, to which I am planning to migrate this blog. I made good progress as first, but soon required a debugger, and took the opportunity to learn the basics of VS Code as a Node editor and debugger. This article will walk through the basics of environment set up and debugging with VS Code.

Wednesday, December 2, 2015

Hexo, a Node.js Blog Platform

It's been five years since I wrote my first blog post, a look at XSLT that still gets pretty good traffic. I chose Blogger because it was free and easy, and the fact Google owned it gave me some confidence it would stick around.  But it's been feeling like less and less of a good fit recently.

Wednesday, November 25, 2015

Creating MongoDB Shards and Replica Sets with PowerShell

In the MongoDB University course "M101N: MongoDB for .NET Developers", there is a walk through of a UNIX script to create a 3x3 set of shards and replica sets. To brush up on my MongoDB and my Powershell, I decided this weekend to try to rewrite and extend the script in Powershell. A somewhat painful, but ultimately rewarding, experience: You can see what I came up with here.  In this post I will walk through some of the powershell and some of the MongoDB syntax and tricks.

Wednesday, November 18, 2015

Custom Sitecore Log files

Starting with Sitecore 6.2, and especially since Sitecore 7 we've seen an increase in specific log files: WebDAV, Crawling, Search, Publishing, FXM. This is completely configurable, and can be leveraged to keep your application logic separate from the Sitecore log file while still using Sitecore's logging capabilities.

Wednesday, November 11, 2015

Autofac Aggregate Service

There is a nice little feature of Autofac called Aggregate Service, that works very well with NSubstitute's recursive mock functionality to make tests much more maintainable and resilient to dependency modifications.

Wednesday, November 4, 2015

A RoboMongo Trick

RoboMongo is a nice tool for digging around xDB databases. It provides the full feature set of the JavaScript shell (you can save variables, run help commands, etc.) and allows you to do things like edit documents directly through the JSON display.

Wednesday, October 28, 2015


One of the key benefits of unit testing is that it pushes you to code to abstractions. Each class has a clear inside and outside, and your tests document the inside bits. The outside stays wrapped in an interface or abstract class so we can change its behavior in tests. When you go down this path, having a tool to make fake versions of interfaces in a simple and painless way is key, which is why I recommend NSubstitute. It is elegantly simple, very flexible, and makes it hard to get into trouble. In this post I will go over some fundamentals of NSubstitute, and compare them to how things work in the more well known Moq library.

Wednesday, October 21, 2015

Unit Testing an Event Handler with Sitecore.FakeDB

In my last post, we looked at how to make an event handler unit testable by wrapping an interface around the Sitecore log, so that we could use NSubstitute to verify the calls made to it.

This only part of the story, of course. For our tests to be meaningful, we need to be able to "arrange" the input that goes into our code, before we make it "act" and before we "assert" how it should behave. Since we are building an ItemSaved handler, we need a way to create Sitecore items in our unit tests.  There is a tool, Sitecore.FakeDB, that makes this straigtforward.

Wednesday, October 14, 2015

Testable Event Handlers using Sitecore's Configuration Factory

It's a not widely know feature of Sitecore configuration that it allows you to specify parameters for event handlers and pipeline processors. This can be used in combination with wrapper interfaces to write unit testable Sitecore code.

Sunday, September 27, 2015

Test Driven Sitecore Links

I'm honored to be speaking at the SUGCON conference in New Orleans next Thursday on Test Driven Development with Sitecore.  Here are some links related to the talk.

Saturday, July 4, 2015

A Scrum Reading List

On a recent project I played a pretty active, if informal, role as an agile coach, in addition to my development duties. Which meant I did a lot of reading on plane flights, watched a lot of Jeff Sutherland videos, and got to the point where I could quote the Scrum Guide in chapter and verse. I'm not a certified anything (well at least as far as Agile is concerned), but the material started to make sense to me in a fairly coherent way, so I thought it might be useful to assemble a list of resources that influenced my thinking, and what I learned from them.

Sunday, February 8, 2015

MongoDB for Sitecore

Starting with Sitecore 7.5, MongoDB has become an integral part of the Sitecore ecosystem. This post will walk developers through the process of installing MongoDB, and cover some of the basics of MongoDB CRUD operations, and then look at how to access Sitecore data with MongoDB.