Firefox runs as a 32-bit application on Windows, so it uses the 32-bit version of Java. I should have read the fine print on the Java website. It tells you to install both 64 and 32-bit versions if you are on a 64-bit system, but are running a 32-bit browser. I did, and now my Java version is up to date in Firefox.

If you are on a 64-bit Windows machine and run Firefox, you may want to make sure you are upgraded to the latest version of 32-bit Java. You can find out by going to the Addons Manager in Firefox, clicking the “Plugins” tab on the left, then click the “Check to see if your plugins are up to date” link at the top of the page. If Java is out of date, it will give you a red warning.

One way to increase security is to ensure that passwords and other sensitive information are not laying around in our config files unsecured (in plain text). All too many times I have seen something like the following in a config file:

Code Sample:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <appSettings>
        <add key="UserName" value="PresidentSkroob" />
        <add key="Password" value="12345" />
    </appSettings>
</configuration>

Fixing this problem is as easy as using Microsoft’s Data Protection API. Just encrypt the value by calling ProtectedData.Protect(). And to decrypt the value, call ProtectedData.Unprotect().

Both methods take an entropy value (salt), and a DataProtectionScope value that defines the scope for which the value should be encrypted. The scope may be one of the following: CurrentUser – Only the current user can decrypt the value, or LocalMachine – The value can only be decrypted on the local machine. CurrentUser can be a little complicated since it may require you to impersonate users in certain cases, so I just use LocalMachine. This does mean that you can’t ship the config file with the values pre-encrypted because they will not be decryptable on the machine its installed on (it can only be decrypted by the machine that encrypted it).

The functions return a byte array, so I Base64 encode the values prior to writing them to the config file. To do this, I wrote a few extension methods. Here they are:

Encryption:

/// <summary>
/// Converts a string to a protected value (encrypted using Data Protection API)
/// </summary>
/// <param name="value">The value.</param>
/// <param name="entropy">The entropy.</param>
/// <returns></returns>
public static string ToProtectedValue( this string value, string entropy )
{
    var entropyBytes = Encoding.UTF8.GetBytes( entropy );
    var valueBytes = Encoding.UTF8.GetBytes( value );
 
    var securedBytes = ProtectedData.Protect( valueBytes,
                                              entropyBytes,
                                              DataProtectionScope.LocalMachine );
    
    return securedBytes.AsBase64();
}

Decryption:

/// <summary>
/// Converts a string to a protected value (encrypted using Data Protection API)
/// </summary>
/// <param name="protectedString"></param>
/// <param name="entropy">The entropy.</param>
/// <returns></returns>
public static string ToUnprotectedString( this string protectedString, string entropy )
{
    var entropyBytes = Encoding.UTF8.GetBytes( entropy );
    var encryptedBytes = Convert.FromBase64String( protectedString );
    
    var decryptedBytes = ProtectedData.Unprotect( encryptedBytes,
                                                  entropyBytes,
                                                  DataProtectionScope.LocalMachine );
    
    return Encoding.UTF8.GetString( decryptedBytes );
}

After encrypting these values appropriately, your config file will look like this:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <appSettings>
        <add key="UserName" value="ADZgAAwAAAABAAAACLYg+TEHoFh88HcfvNTg0yAAAAAASAAACgAAAAEAAAAMFLpAQAAANCMnd8BFdERjHoAwE/Cl+sBAAAA8BdWygYhjUWaw3teJQo04AQAAAACAAAAAAXFMCeBnOURIBAl2DJoQAAAAN7+sLiIZl+x9vPjC16wcmRQAAADS4d9bdlcLF9CmKrsbgGWPM29zAQ==" />
        <add key="Password" value="AQAAANCMnd8BFdERjHoAwE/Cl+sBAAAA8BdWygYhjUWaw3teJQo04AQAAAACAAAAAAADZgAAwAAAABAAAAAhfu4ghotvmXphmGWOHFfbAAAAAASAAACgAAAAEAAAAMBMv0D9/mDwktrFSVNIPcwQAAAAwg2IDL1+MOHwdx2A1cax2RQAAACZLB62COjpupN2+pW4yT8LKR5Udg==" />
    </appSettings>
</configuration>

Now you and your clients can sleep a little better at night knowing their sensitive information is just a bit more secure.

1. To cover a very wide range of topics so that newcomers to the craft can gain an understanding of the full scope of modern software development practices. As such, there is not time to cover any one topic in very much detail
2. To provide links to detailed information on each topic so that anyone could dig in deeper to learn about anything presented that they wanted to begin putting into practice

This second manner of presenting information required a different medium. If I wanted people to have access to all these links, I knew that I couldn’t just put links on my slides…no one would want to write them all down. And after all, we are technologists…I had to use something suitable to the audience, so I thought Twitter would be a more suitable way to convey the links during my presentation. I did some searching and found a script that would send tweets from the presenter notes as you moved through the slides of an Apple Keynote presentation. The script is called Keynote Tweet 2.

So as I went through the slides, the resources were tweet(ed?) out over the #Padawan2Jedi hashtag. I really wanted them to walk away with all the links to the resources, and they did. The talk lasted 2 hours, and my screencast recording software (Camtasia) died halfway through, so if you notice a change in the audio, partway through, that is why. I also had to re-record the last half of the video of the slides, so if they aren’t perfectly in sync with the talk, that is why. (Its amazing how hard it is to anticipate when to change the slide…even when you were the one talking…)

• Padawan 2 Jedi Slides (Apple Keynote File) (The keynote file is 30MB because of all the Star Wars images.)
• Padawan 2 Jedi Slides (PDF)

Here is the abstract that I submitted for the talk:

Are you wanting to become a better developer, but don’t know where to start? Do the terms TDD, BDD, CI, SOLID, etc. seem foreign to you? This two part presentation will cover many of the modern development practices today that every developer should know. Learn about object oriented design principles, design patterns, testing (mocking, TDD, BDD), source control, continuous integration, agile practices, plus many useful tools and techniques. That’s a lot to cover, so while some topics will be discussed in-depth, others will be touched on lightly, with resources on where to get more information. The purpose of the presentation is to give a broad overview of how modern developers work and the tools they use to be efficient and productive and provide resources so that any aspiring developer can get on the fast-track to becoming better at their craft.

Introduction to MongoDB – Austin Code Camp 2011.key (Keynote presentation file)

Introduction to MongoDB (Austin Code Camp 2011) from Chris Edwards on Vimeo.

The first will by my Introduction to MongoDB talk that I have given several times…

Introduction to MongoDB

MongoDB is one of the new breed of “NoSQL” databases available as alternatives to relational databases. It is a document database that represents its data as JSON, and thus requires no schema. It can easily scale across many machines using sharding and replication. Come get an overview this database, its scalability and redundancy features, and how to access it via C#. While MongoDB is not meant to replace all SQL databases, its good to know there is an alternative for the cases where it is the better fit.

This is the same talk I gave at the code camp last year, however I have updated it to include a lot of new functionality released in MongoDB v1.8 and some upcoming features of v1.9. I also incorporated animations to help explain the movement of data across shards and other internal workings of Mongo. I have found animations to be invaluable to helping explain complex interactions. I feel they will add a lot to the presentation.

Right after my MongoDb talk (in the same room), a colleague of mine, Josh Peterson, will be presenting the open source C# LINQ provider for MongoDB that he wrote here at BancVue. The provider works with the 10gen-supported C# driver. Its some pretty cool code. If you use MongoDB with C#, it will be worth your time to check it out.

The other two presentations are actually a two-part series. Below is the abstract for them:

From Padawan To Jedi — A Developer Jump-Start

Are you wanting to become a better developer, but don’t know where to start? Do the terms TDD, BDD, CI, SOLID, etc. seem foreign to you? This two part series will cover many of the software development principles, patterns & practices that every developer should know. The goal is to give a broad overview of how modern developers work, and to provide resources to help any aspiring developer get on the fast-track to becoming better at their craft.

Episode 1: The Theoretical Side of the Force

We all know good design when we see it. But why is one design better than another? How can we consistently create code is worthy of being called great? In this episode, we will look at the theoretical side of software development and see the principles and patterns that form the foundations of good design. We’ll look at the importance of testing and learn about good test design, TDD, BDD, mocking, AAA, and more.

The goal of this talk is to give you a broad overview of design theory and testing techniques, so we will cover a lot of ground quickly. I’ll be tweeting links to related resources and articles throughout the talk. Follow @cedwards or hashtag #Padawan2Jedi during the talk so you can dig in and learn more afterwards.

Episode 2: The Practical Side of the Force

Being a productive developer is far more than just typing in code, especially when working in a team. In this episode, we look at basics like source control, automated builds and refactoring. We’ll also touch on more advanced topics like continuous integration, IoC containers, ORMs, and application architecture. We’ll finish by discussing agile software development practices and how they enhance the software development process.

The goal of this talk is to give you a broad overview of modern practices, processes and tools, so we will cover a lot of ground quickly. I’ll be tweeting links to related resources and articles throughout the talk. Follow @cedwards or hashtag #Padawan2Jedi during the talk so you can dig in and learn more afterwards.

In this talk I will be using a new script called Keynote Tweet that will automatically tweet content for each slide in a Keynote presentation. I plan to cover a broad range of topics, and can’t get into a lot of detail in the allotted time, so I wanted to make the resources available to anyone who wants more information. I think twitter is an excellent way to do this. Anyone interested can follow me , or the hashtag (as mentioned above), but I won’t be tweeting the links on the #AustinCodeCamp hashtag because I don’t want to flood the channel.

I hope to see you there!

-Chris

Leading by Position

Leading by position is when others follow you only because you are in a position of authority. “Do this…because I am your boss!” While people should follow those in a position of leadership, if a leader is relying solely on the authority of their position to lead others, it is far from ideal.

Leading by Influence

Leading by influence is the ideal form of leadership. This is where others follow because you have earned their trust and you are able to exert influence over them. This form of leadership does not require any authority or position. A person can lead their peers solely by influence.

Have you ever heard the saying, “He’s a natural born leader?” It is likely because of influential leadership. Those who naturally appear as leaders in a team of peers are those who lead in this way. The team trusts them and they begin to “naturally” lead even when they haven’t been officially given the title of leader.

An Example

The Bible gives us a great example of this type of leader in Jesus. He was God, yet the bible says, “[Jesus], being in very nature God, did not consider equality with God something to be used to his own advantage; rather, he made himself nothing by taking the very nature of a servant, being made in human likeness.” (Philippians 2:6-7) Jesus gave up his “title” and led by example. He didn’t say “Obey me because I am God!” Instead he said “If you love me, obey my commandments.” (John 14:15)

So, how do you lead?

When the error needs to be displayed or logged, catch it

When you need to do something with the error, you should catch it. For instance, in the UI, you need to display errors to the user. Bubbling it up would mean that it would become an unhandled error, so it needs to be handled. Catch it here so you can do something graceful rather than crash the app.

When you can add additional information about the error, catch it

When a method can add some value to the error message that will help the end user or developer understand what is going on, do so. A good example would be if a sql statement failed, it would be useful to catch the error and add the sql that failed to the error message along with any parameters that may have caused the failure. Then throw a a new error with this message and set its InnerException property to the original error.

Let the error bubble up in other cases

I can’t think of any other reason to catch the error, so just let it on through and bubble up in any other instance.

-Chris

Most of the questions here are very developer-centric, but some also apply to the broader picture.

The Three General Questions

These three questions cover most of what you want in a retrospective, but are too broad to be useful by themselves.

• What worked well?
• What didn’t work so well?
• How can we do better?

Specific Questions

Here are some specific questions I have found useful. Pick the ones that are most relevant to your situation.

General

• What is keeping us from delivering more value?
• Is the path blocked by unresolved obstacles?
• Are we getting to done?
• Are we uncovering new things every retrospective?
• Are we managing risk effectively? (tackling high risk tasks, or avoiding?)
• What were the biggest pain points? What was difficult?
• What low-hanging annoyances can we remove?

Team

• Are the team members happy? Tired? Grumpy?
• Are team members really collaborating? Learning? (in general, and from one another)
• Are we effectively utilizing the strengths of the team members?
• Are team members taking initiative?
• Are we respecting the team norms?

Communication

• How effectively are we communicating?
• How much time does the Product Owner spend with the team?

Environment

• What in our physical space is hampering our effectiveness?

Planning/Execution

• Are we faithfully tracking and discussing effort remaining?
• Are our tasks clearly defined?
• Were our estimates accurate? Why/Why Not? How can we do better next time?
• Were our requirements sufficient?
• Are the user stories too granular? too nebulous?
• Was the workload too much or too little? (Are developers over- or under-worked? Are they energized?)
• Are team members able to do focused work or are they pulled in too many directions?
• Was there an appropriate amount of slack time for cleanup and improvement?

Processes & Practices

• Is our iteration length appropriate?
• Should we pair program more? or less?
• Do we have sufficient test coverage?
• Is the quality of our code sufficient?
• Is our code base improving or degrading? Why?
• Are we adhering to development principles?
• Are we appropriately utilizing automation? (If you do something more than once, try to automate)
• Are we handling the unexpected well or reverting to our old ways?
• Are we utilizing the tools we have effectively?
• Are there any tools that would help us be more effective?

Resources

Some of the questions and concepts were taken from the following cheatsheets by Berteig Consulting.

• AgileWork Retrospective Cheat Sheet
• AgileWork Process Facilitator Cheat Sheet

I started using Paper.li to gather all the urls that are tweeted in a day into one consolidated view that looks like a newspaper. See image.

I simply navigated to http://paper.li to sign up, and entered my twitter id (no password needed) and it generated a daily summary for me! Very nice. Plus, it emails me a link to the summary for each day.

It has really saved me a lot of time trying to catch up on the latest links posted on my twitter feed. I highly recommend it.

-Chris

The target audience is technical people (developers) who have experience with relational databases, but have never looked at MongoDb before. It covers all the basics but also several advanced topics like sharding and replication. I didn’t modify my slides much from the last presentation, but I did cover a lot of material not on the slides.

The talk lasted 2 hours. There are times in the audio where I am walking through the demo of the mongo shell, or the c# code that it may not be too easy to follow with only the audio. I apologize for that.

The most interesting part of the talk (in my opinion) was the replication and sharding, which is at the end (starting at about the 1h 20m mark), so if you are interested in that, you can fast forward there.

MP3 Audio File
Keynote Presentation File

Enjoy.

-Chris

What does it do?

Given:

obj = new TestClass();
obj.Value1 = "abc";
obj.Value2 = "123";

Callling:

obj.ToPrintableString();

Yeilds a string containing:

{{ TestClass { Value1 = [ abc ]; Value2 = [ 123 ]; } }}

This is all generated dynamically with reflection. It will print out any properties with public getters.

The Code

The ToPrintableString() method does most of the work.

public static class ObjectExtensions
{
    public static string ToPrintableString< T >( this T objectToPrint ) where T : class
    {
        Type type = typeof ( T );

        var sb = new StringBuilder();
        sb.AppendFormat( "{{{{ {0} {{ ", type.Name );

        foreach ( PropertyInfo property in type.GetPublicGetProperties() )
        {
            sb.AppendFormat( "{0} = [ {1} ]; ",
                             property.Name,
                             property.GetValue( objectToPrint, null ) );
        }

        sb.Append( "} }}" );

        return sb.ToString();
    }
}

The GetPublicGetProperties() gets the properties with public getters. This method is part of my ReflectionExtensions class. I include it here for completeness.

public static class ReflectionExtensions
{
    public static PropertyInfo[] GetPublicGetProperties( this Type type )
    {
        return type.FindMembers( MemberTypes.Property,
                                 BindingFlags.Public | BindingFlags.Instance,
                                 ( m, f ) => ( (PropertyInfo)m ).CanRead,
                                 null )
                            .Cast< PropertyInfo >()
                            .ToArray();
    }
}

This code can be found in my Shiloh.Testing github repository.

Enjoy!

-Chris

Usage

First let’s look at how we would use the method by looking at the tests. The method is called should_be_equal_to().

public class TestClass1
{
	public int Value1 { get; set; }
	internal int Value2 { get; set; }
}

public class TestClass2
{
	public int Value1 { get; set; }
}

[ TestFixture ]
public class GlobalEqualityAssertionTests
{
	[ Test ]
	public void comparing_two_identical_instances_of_the_same_class_should_pass()
	{
		var obj1 = new TestClass1 {Value1 = 1};
		var obj2 = new TestClass1 {Value1 = 1};
		obj1.should_be_equal_to( obj2 );
	}

	[ Test ]
	public void comparing_two_instances_of_different_classes_that_have_the_same_public_property_where_both_instances_have_the_same_value_for_that_property()
	{
		var obj1 = new TestClass1 {Value1 = 1};
		var obj2 = new TestClass2 {Value1 = 1};
		obj1.should_be_equal_to( obj2 );
	}

	[ Test ]
	public void comparing_two_instances_of_different_classes_that_have_the_same_public_property_where_the_values_for_that_property_differ()
	{
		var obj1 = new TestClass1 {Value1 = 1};
		var obj2 = new TestClass2 {Value1 = 2};
		Assert.Throws< AssertionException >( () => obj1.should_be_equal_to( obj2 ) );
	}

	[ Test ]
	public void comparing_two_instances_of_the_same_class_where_an_internal_property_differs_should_pass()
	{
		var obj1 = new TestClass1 {Value1 = 1, Value2 = 1};
		var obj2 = new TestClass1 {Value1 = 1, Value2 = 3};
		obj1.should_be_equal_to( obj2 );
	}

	[ Test ]
	public void comparing_two_instances_of_the_same_class_with_different_values_should_fail()
	{
		var obj1 = new TestClass1 {Value1 = 1};
		var obj2 = new TestClass1 {Value1 = 2};
		Assert.Throws< AssertionException >( () => obj1.should_be_equal_to( obj2 ) );
	}
}

The Code

Here is the main part of the method…

public static void should_be_equal_to< TActual, TExpected >( this TActual actual, TExpected expected )
{
	foreach ( PropertyPair propertyPair in GetPropertiesToCompare( actual, expected ) )
	{
		object actualValue = propertyPair.Actual.GetValue( actual, null );
		object expectedValue = propertyPair.Expected.GetValue( expected, null );

		Assert.That( actualValue, Is.EqualTo( expectedValue ),
			string.Format( "Expected {0} to match, but did not.", propertyPair.Expected.Name ) );
	}
}

This code loops over all the PropertyPairs we want to compare and compares them. If any value does not match it will fail the assertion with a meaningful error message.

The PropertyPair class is implemented as a private inner class within the assertion class.

private class PropertyPair
{
	public PropertyInfo Expected { get; set; }
	public PropertyInfo Actual { get; set; }
}

Lets look at the code that creates these pairs.

private static IEnumerable< PropertyPair > GetPropertiesToCompare< TActual, TExpected >( TActual actual, TExpected expected )
{
	return
		from exp in GetComparableProperties( expected )
		join act in GetComparableProperties( actual )
				on new {exp.Name, exp.PropertyType}
				equals new {act.Name, act.PropertyType}
		select new PropertyPair {Actual = act, Expected = exp};
}

private static IEnumerable< PropertyInfo > GetComparableProperties< T >( T actual )
{
	return GetPublicGetProperties( actual )
					.Where( property =>
							!property.PropertyType.IsClass &&
							!property.PropertyType.IsInterface
					);
}

private static IEnumerable< PropertyInfo > GetPublicGetProperties< T >( T obj )
{
	Type type = obj.GetType();

	return type.FindMembers( MemberTypes.Property,
					 BindingFlags.Public | BindingFlags.Instance,
					 ( m, f ) => ( (PropertyInfo)m ).CanRead,
					 null )
					.Cast< PropertyInfo >();
}

GetPropertiesToCompare() simply gets the comparable properties for each object type and joins them on name and type. Any properties that don’t match on name and type are ignored. Those that do match are put into a PropertyPair object to be returned.

GetComparableProperties() calls GetPublicGetProperties() to get a list of public readable properties. It then throws out any reference type properties so that only value properties are left. These are the properties that get compared.

Caveats

Note that reference properties (properties that refer to other objects) are not compared, so even if they differ, the objects will show as equal. I have deferred this task since I still need consider how to handle references we don’t want to compare (and there are many).

Where Can I Get It?

This code can be found on my Shiloh.Testing github repository. The link goes to the v0.1 tag, which only has this class and its supporting classes and tests. It includes several other features that I stripped out to make this blog post simpler, like the ability to clean up values before comparing them, and an attribute you can place on properties you want to ignore when asserting equality.

I hope this simplifies your testing…it has definitely simplified mine.

-Chris

The talk covers MongoDB from the perspective of a newcomer to the technology. I relate the concepts in MongoDB to their corresponding SQL idioms–pointing out their differences and likenesses. The talk covers much of the functionality and capabilities of MongoDB, from the simple to the complex (queries, indexes, sharding, replication, installation, etc.). A lot of questions that are asked push deeper into the internals, many of which I answer, but several I defer with a simple “I don’t know”.

The talk went much longer than I expected–over 2 hours. I was told it was the longest meeting they ever had. I was pleased at how engaged everyone was. There were so many questions, and many people seemed genuinely interested. I thoroughly enjoyed giving the talk. Can’t wait to do it again!

Resources:

• Download the audio (29.8 MB)
• Source code from the talk on github

Topic: Introduction to MongoDB
The relational database has been around for a very long time. It is used in almost every kind of application imaginable. Most all developers have experience using an RDBMS and use it on almost every project by default. When was the last time you considered using an alternative? You haven’t? Let me invite you to take a step outside the box for a moment.

MongoDB is one of the new breed of “NoSQL” databases available as alternatives to relational databases. It is a document database that represents its data as JSON, and thus requires no schema. It can easily scale across many computers using auto-sharding and supports redundancy for each shard. Come get an overview this database, its scalability and redundancy features, and how to access it via C#. While MongoDB is not meant to replace all SQL databases, its good to know there is an alternative for the cases where it is the better fit.

Speaker: Chris Edwards
Chris Edwards is a senior software developer with BancVue, Ltd. based in Austin, TX. He has over 15 years of professional software development experience in a diverse set of environments and technologies, but has mostly focused on the Microsoft stack. Chris decided at a young age to pursue software development after seeing the movie WarGames, and has never looked back since. Now 26+ years later he is still writing code with the same passion. Chris has presented as several of the Austin Code Camps, and actively promotes and contributes to open source software. When not coding, he can be found spending time with his family or serving at Hill Country Bible Church, Hutto. He blogs at https://chrisedwards.dreamhosters.com/ and you can find some of his work on http://github.com/chrisedwards/

Monday November 8th 5:30-8:00pm

***New Location***
Microsoft Technology Center: Austin
Quarry Oaks II
10900 Stonelake Blvd., Suite 225
Austin, TX 78759
(512) 795-5300

What the heck is Nu?

Nu is a package manager for .NET (finally!). It allows you to install code libraries and all their dependencies automatically, and keep them updated. If you have ever heard of RubyGems, this is the same thing. In fact, its built on top of ruby gems!

Installing Nu

To use Nu, you first need to install ruby. You can get it here. Then upgrade RubyGems by dropping to a command prompt and typing

gem update --system

Then to install Nu you type

gem install nu

And thatâ€s it…Nu is installed and ready to go.

Using Nu

Using Nu is dirt simple. Wanna install NUnit?

C:\project>nu install nunit
Gem nunit is not installed locally - I am now going to try and install it
Successfully installed nunit-2.5.7.10213.20100801
Installed package nunit.

Done! How about NHibernate?

C:\project>nu install nhibernate
Gem nhibernate is not installed locally - I am now going to try and install it
Successfully installed nhibernate-2.1.2.4000
Loading dependency: castle.core = 1.1.0.0
Loading dependency: castle.dynamicproxy2 = 2.1.0.0
Loading dependency: castle.core = 1.1.0.0
Loading dependency: log4net = 1.2.10.0
Installed package nhibernate.

Sure beats the pants off navigating out to the website to download the latest version, doesnâ€t it? And it even installed all the dependencies.

Creating a gem to be installed using Nu

So what does it take to make a project installable using Nu? Not much. I was surprised at how easy it was.

When I converted Fluency to install all its dependencies using Nu, I found one library that that wasnâ€t yet packaged as a gem and installable through Nu. This was the SharpTestsEx library. So I did what any self-respecting supporter of open-source software would do, I decided to add it myself so anyone else could use it.

1. Prepare the gemspec

To do this, I created a gems folder and in it, a gemspec file “sharptestsex.gemspec” with the following contents

version = File.read(File.expand_path("../VERSION",__FILE__)).strip

Gem::Specification.new do |spec|
  spec.platform    = Gem::Platform::RUBY
  spec.name        = 'sharptestsex'
  spec.version     = version
  spec.files = Dir['lib/**/*']
  
  spec.summary     = 'Sharp Tests Ex - .NET Fluent Assertions for Your Tests'
  spec.description = '#TestsEx (Sharp Tests Extensions) is a set of extensible extensions. The main target is write short assertions where the Visual Studio IDE intellisense is your guide. #TestsEx can be used with NUnit, MsTests, xUnit, MbUnit.'
  
  spec.authors           = ['Fabio Maulo','JDiamond']
  spec.email             = ''
  spec.homepage          = 'http://sharptestex.codeplex.com/'
  spec.rubyforge_project = 'sharptestsex'
end

and a “VERSION” file that simply contained the version number

1.0.0.0

I then created a gems/lib/ folder and placed the binaries in it. The spec.files attribute indicates that I want to include all the files in this folder in the gem.

2. Build and test the gem locally.

Then I built the gem at the command prompt with

gem build sharptestsex.gemspec

This will product the gem file names sharptestsex-1.0.0.0.gem. I tested it with nu locally by installing the gem directly (without going to the rubygems server) by specifying the filename of the gem.

gem install sharptestsex-1.0.0.0.gem

This installed it from my local drive into the gem cache. The gem cache is where nu gets the libraries. If nu does not find the requested library in the gemcache, it asks rubygems to get it from the server. Installing it like I did above ensured its in the cache so nu could find it. Then I tested that nu could install it.

nu install sharptestsex

Once I saw it all worked, I uninstalled the gem so that I would be able to test that it pulls from the server. Uninstalling the gem deletes it from the local gemcache. I had to do this because if it existed in the cache, it wouldnâ€t even try to download if from the server the next time I test it. I uninstalled it with…

gem uninstall sharptestsex

3. Push the gem to RubyGems.org

Now I was ready to push the gem out to RubyGems.org. To do that, I needed to sign up for a free account, which was quick and painless. The I pushed the gem up.

gem push sharptestsex-1.0.0.0.gem

I was prompted for my RubyGems.org login and password, and then the gem was uploaded. 

4. The final test

Then my new gem is ready to install with nu! I tested it with…

nu install sharptestsex

I checked, and sure enough, I saw a lib folder that contains a sharptestsex folder with all the binaries. It was way easier than I thought.

Resources

I drew heavily from the following resources while getting this to work.

• How To: Gems and .NET – Rob Reynolds, “The Fervent Coder”
• Creating a "New" Gem for "Nu" – From 0 to 100 in 24 Hours – Bill Simser

Start a Developer Book Club – Here at BancVue, we have a developerâ€s book club that meets each Wednesday over lunch. The group decides what book they want to read, and then takes it a chapter (or sometimes a section) or so each week. We discuss what we have read and learn from one another to help keep our skills sharp.

Hold Weekly Dev-Shares (Knowledge Shares) – Each week we have a different developer share something they have learned, something they have worked on, or some other presentation that would benefit the other developers. Its a great way to spread knowledge or promote new technologies. We identify topics the developers as a whole need to know and ensure those topics are discussed. However, most of the time it is whatever the presenting developers choose to present. Its a great forum to show ways other developers have found to make your work easier. Its been used to discuss company tools or how to overcome common problems in the codebase or toolset. It helps increase the collective knowledge of the teams.

Get Safari Subscriptions – BancVue provides several subscriptions to Safari Books Online that the developers have access to. This is a great resource for the developers to learn from. Several members of the book club use it to read the books. I have used it on many occasions to learn more about technologies relevant to whatever project I am working on.

Start a Developer Library – I personally bring up several of my development books and have them at my desk for any developer who wants to read them. I have seen places that sponsor a company library that is stocked with current books to help developers learn.

Practice Pair Programming – If you arenâ€t doing pair programming, you are really missing out on a learning opportunity. Pairing is a great way to transfer knowledge. Each developer has their own bag of tips and tricks they have learned over the years. Paring allows the whole team to leverage this knowledge.  This is also true of domain knowledge. A great way to grow a junior developer is to pair them with a senior. Even the senior devs will benefit. I have learned A LOT through pairing, even from devs that are many years my junior.

Start Mentoring – Another way to really help developers grow is to assign them a mentor. Ideally each developer is both being mentored, and mentoring others. Senior devs mentor mid-level devs, who mentor junior devs. Senior devs can be mentored by other senior devs who have more experience, etc. Regardless of whether this is done formally or not, encourage the developers to take on an attitude of mentorship.  Everyone should be continuously learning from each other.

Ask for a Training Budget – Ask management to encourage outside training by providing funding for it. BancVue has a budget for training that can be used for conferences, online training or other courses. Some good examples would be attending JP Boodhooâ€s Nothin but .NET course, or Udi Dahanâ€s SOA course, etc.

Use Screencasting – At BancVue, we screencast our dev shares. This way anyone who missed can still see it, plus, as we bring new employees on, they can benefit from them as well. We also have used them for training on company tools and walkthroughs of common tasks. A good example would be a screencast on how to set up a developerâ€s box.

Get Training Videos – There are many video training resources available. Some are free, and some are for purchase. There are many great free videos out there. The purchased ones, however, often cover the topic in much more detail, but this is not always the case. Get videos that cover the technologies you are using, or the techniques the team needs to learn. Make them available to all the developers on a drive share or wiki. Make sure you watch the videos (or a sample of them) before making them available. You want to make sure they arenâ€t a waste everyoneâ€s time. Some good sources for videos are:

• Free
  • DimeCasts.net – A great site with short 10-minute videos on all types of development topics. The length is perfect for the ADD-impaired (like myself).
  • Virtual Alt.Net – This site holds a collection of virtual meetings/screencasts on various topics. Check out the “Recordings” tab.
  • InfoQ – This is far more than videos. It constantly has great new content. I suggest subscribing to their newsletter, which is just a concise set of links to all their new content.
• Paid
  • TekPub – High quality training screencasts on several development topics.
  • The Pragmatic Bookshelf Screencasts – I got Kent Beckâ€s TDD videos off here and they were great.

Broadcast Useful Resources – When you learn of upcoming user group meetings or training opportunities, let all the developers know. I do this often. When the Austin Code Camp comes around each year, I personally invite every developer to come. When I find a great link that I know others would be interested in, forward it to them. I am always trying to make resources available to those who could use them.

Start a Blog – Starting a blog is not only a good way to learn technology yourself, its a great way to teach others what you are learning. If you want to lead others in your company how to use a particular method or tool, what better way than to write up a blog post and refer them to it. You will not only help the developers you work with, but you will be contributing to the developer community at large. I canâ€t count how many times I have directed others to my blog for something they have questions about.

Give a Presentation at a Local User Group – Find a topic you are passionate about, and give a talk on it. Itâ€s a great way to get people to come to the user group who may not otherwise come. They may come just because its you. It also encourages other developers to start doing the same. They see that you donâ€t have to be a genius to do these things. It ups their confidence. Not only that, but in doing so, you will learn a lot. The saying is true, “If you want to learn something really well, teach it.”

Keep up with Twitter – To get a lot of resources and stay current, follow leading developers on twitter. The resources you can get from there are great. I find myself relying more on twitter and less on my RSS feeds for current information these days.

Read Books – This will help you stay current and keep your skills sharp. Aside from the obvious benefits to yourself, this also lets you determine what books you may want to suggest to others, or to the book club.

Well, thatâ€s a lot of tips. The bottom line is, the change starts with you. I encourage you to implement some (or all) of these tips. Not only will you grow to be a better developer, but so will everyone around you. You will be a blessing to your company and your team, and create a better place to work in the process. Go for it!

-Chris

I like to think of myself as a mentor. I try to help others become better developers. I make it my mission at work to teach and instruct every chance I can. When I do so, however, I can often be critical. I can easily resort to tearing people down by criticizing their code rather than building them up by encouraging them and teaching them. There is a huge difference between the two, and I need to constantly remind myself of this.

It makes me think of how Jesus could hang out with prostitutes and sinners, yet still be a mentor and guide for them. He demonstrated what was right by his life, and told them what was right in his speech, but he never pointed the finger at them. These people wanted to be with him, even though his life and teaching showed them that their lives were wrong. He was a positive influence on them, without being directly critical of them. He told them the truth when necessary, but did so with love.

So I have to ask myself, am I building people up, or tearing them down? And I ask you the same question. I challenge you to make it a priority to join with me and set the criticism aside. Be a positive influence on those around you. Teach others what you know, and learn from others what you do not.

Be a mentor, not a critic.

-Chris

One problem with WCF is the size of the configuration files. They contain so much data they are unreadable. Its such a problem that Microsoft provides the WCF Configuration Editor to ease developers pain when editing them.

This is even more of an issue when users need to edit them. I have user-editable configuration settings in my app.config, but since the  WCF settings also reside in that file there is a risk that users will accidentally change them and cause failure. Not good.

WCF is a good example of a bloated config file, but the problem is not isolated to WCF. Anytime a config file contains non-configurable concerns, it is bloated.

You see, a bloated config file contains 2 types of data:

1. User-editable configuration settings
2. Static application configuration (should never change…in my case, this is WCF binding configuration).

This violates SRP. Yes, I know, the Single Responsibility Principle applies to objects/classes, but it often applies beyond that scope as well.  In this case it applies at the file-level. A config file should have one and only one responsibility: user-configurable settings. Anything beyond that introduces confusion and increases risk when editing the file. If the users should never edit the WCF bindings, keep them out of the config file.

So how do we fix it? Configure the WCF bindings in code rather than the config file. Expose only the WCF settings the users should modify as settings in the config file (endpoint addresses, timeouts, etc). Express everything else in code or in another file, safely out of reach. The result is clean config files that users can understand and edit without the fear of changing something they shouldn’t.

-Chris

Purpose / Content

Entities are the domain objects. They model the data that gets persisted to the database. These objects are mostly data, and have little behavior.

Services are the workhorses of the application. They perform the majority of the business logic. These objects have little to no state, and are almost pure behavior.

Resources are the objects that interface with outside dependencies like the file system, database, etc. These objects only have the business logic necessary to interface with these outside dependencies. They are used to decouple the application from the dependency itself. A good example of a resource is a repository—which serves as the source for entities.

Dependencies

Entities only have dependencies on other entities through relationships, such as, an order having line items. An entity should never depend on services or resources.

Services can depend on anything. Services require dependencies on other services or resources to perform complex tasks—per the Single Responsibility Principle.

Resources generally only depend on the underlying subsystems they are encapsulating. Resources donâ€t depend upon other services, but may depend upon other resources.

Testing

Entities require the least amount of testing. They are mostly data and have simple behavior—there is little to test. But entities are used heavily in testing other objects. The serve as input and expected values when testing services and resources. Because there is so little behavior, it is easiest to use entities directly in the tests rather than mock them. (This is where frameworks like Fluency come into play to help create these objects in a state containing valid anonymous data. What mocking is to Services and Resources, Fluency is to Entities.)

Services require a great deal of testing since they are mostly behavior. Unit testing them requires mocking any other services or resource they depend on. Any entities needed to test them are created and used directly.

Resources cannot be covered in unit tests. Because they interact with underlying systems (disk, database, network, etc), any test against them is, by nature, an integration test. Resources are always mocked when unit testing other objects since they represent dependencies that we want to decouple our tests from.

Architecture

Entities are the core of the Domain Model. They represent the business domain directly.

Services can be part of the domain model or a part of the infrastructure model depending on the behavior they are supporting. For instance, a notification service would be an infrastructure concern while a loan calculation service would be a business domain concern.

Resources are always part of the infrastructure for obvious reasons.

Other

Are there any other observations you can make about these three types of objects that can help us in our thinking? If so, please add your comments. I would love to hear them.

-Chris

Perfectionism is something I have struggled with for a long time. I often feel dissatisfied with my code because the code is not “just right”. Time and time again I have found myself up against deadlines trying to clean up code that I should have left alone. It is something I have resolved to overcome, and if you suffer from this handicap, I urge you to do the same.

So what is good enough?  How do I know when to stop?

This is a hard question to answer. To get started, we need to know what good software is. I would propose that good software is software that works,  is understandable, maintainable and usable. Given this, the question can be rephrased as four smaller questions:

• Does it work well enough?
• Is it understandable enough?
• Is it maintainable enough?
• Is it usable enough?

Answering these questions should give us a good understanding of what is good enough, and perhaps help us overcome our perfection fetish.

Does it work well enough?

This is a question of requirements. Does the software meet the requirements? Is it stable? Does it meet the defined SLAs? If the answer is to any of these questions is no, then the software is not good enough. If the answer is yes, then we can move on.

Is it understandable enough?

Is the code clear? Can other developers read and make sense of it? Could they pick up development on it if you were hit by a truck?

Is it maintainable enough?

This is where I always get trapped. Can you reasonably modify the code to handle unforseen requirements changes? Is it flexible where the business rules are flexible? If not, can it easily be refactored to be flexible? I have trouble deciding what refactorings to do now, and which to save for later if we need them.

I am often afraid of painting myself into a corner—its a fear of being unable to change when necessary. I recently realized that following good agile practices (TDD, etc…) makes it much harder to paint yourself into a corner. Test coverage and good design allow you to easily refactor yourself out of any pinch.

Remembering to embrace change rather than fear it helps me to put off till tomorrow those things that are not necessary for today.

Is it usable enough?

Can the user accomplish the tasks they need to with the software? Can they do so efficiently and without complaint? An application that is not usable is useless. An app that is overdesigned, however, is wasteful and expensive.

A word of caution

I am not advocating that we develop mediocre software with mediocre design. Please realize that this is written to those developers who have a perfectionist bent, who see great software and great design as something that could be must be improved. Their “good enough” is everyone elseâ€s “great”.

In the competitive world of software development and its pressures to deliver, we must strike a balance between quality and cost. The higher the quality of our code, the longer it will take to develop. In this world, the perfectionist will be forever unhappy with their results given the short time they are allotted. They will never be satisfied, that is, until they can overcome their perfectionism.

Fight Perfectionism! Know when to say when. Then move on.

-Chris