Agile Process Definition

Recently I have been challenged by coming into a new startup which is still finding it’s way with agile and just work item management.  Over the years, I have managed and lead many different teams and below is the outline that I have found to work in my experiences.  That being said though, remember that agile is also about being nimble and fulling adopting the phrase inspect and adapt. Continue reading

Advertisements

Moq and entity

So this week while trying to implement a repository pattern within a MVC Web API project I found myself writing unit tests to verify that the response is what we would expect.  As part of this, the entity query was using the DbFunctions.AddDays method.  When you mock the backing DBSet collections, the code does not know what to do with these DbFunctions and will throw an error. Continue reading

JSON standards vs C# naming standards

Anyone that has coded in C# for any amount of time is accustom to seeing property names in Pascal case such as the example below…

public class MyClass {
    public string MyString { get;set; }
    public int MyInt { get;set; }
}

Which will serialize the class as follows…

{ "MyString":"hello world","MyInt":1 }

Some of your JSON gurus would tell you that the properties for a JSON object should really be in camel case instead of pascal (examples). So we are in-between worlds here trying to find something that will work for everyone.

Our first option would be to use the JsonPropertyAttribute to specify the name for the property during serialization such as below…

public class MyClass {
    [JsonProperty("myString")]
    public string MyString { get;set;}
    [JsonProperty("myInt")]
    public int MyInt { get;set; }
}

Option two would be to make a change in the serialization options such as below…

    MyClass obj = new MyClass()
    {
        MyInt = 1,
        MyString = "hello world";
    };
    var jsonSettings = new JsonSerializerSettings
    {
        ContractResolver = new CamelCasePropertyNamesContractResolver()
    };
    string json = JsonConvert.SerializeObject(obj, Formatting.Indented, jsonSettings);

Both of which will give us our desired output of…

{
  "myString": "hello world",
  "myInt": 1
}

This may be most useful when working within the WebAPI technology of asp.net. If you would like to set the serializer to camelcase for the entire api, you would would need to add the below line to your Application_Start() method within your global.asax

            GlobalConfiguration.Configuration.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

Fun with MVC Action Filters

Today while working in an MVC web application I ran into a scenario where I needed to authorize access based on an internally developed authorization system.

At first I thought about overriding the OnAuthorization() method in the controller which I’ve done in the past, but then I realized that the permissions could be different based on the action which is invoked on the controller. Because of this, something on the controller level may have been too restrictive, Continue reading

Show Season

Nothing helps a little cabin fever then fishing show season.  I’m typically not a fan of the winter months.  I enjoy the outdoors far too much to be cooped up inside of a house except for when we have to go places.

The one thing that I do enjoy though is the show season.  Usually in this area it start off with fishing shows Continue reading

Agile planning poker with remote teams

Anyone that has been working in agile software development has undoubtedly used some form or planning poker.  A common standard is to have sizing meetings with the team, and in these meetings the team comes together and measures the complexity of a unit of work commonly referred to as a user story.

During these meetings, the team will commonly use what is referred to as the Fibonacci sequence to rate the complexity of the unit of work to be done.  Some people will by default try to tie this back into hours to complete the story.  Please understand that this is not the purpose of this exercise.  The team should rate each story for the level of complexity to complete.  Some people will even discuss and agree on a comparison sheet in that they will look back at completed work items and say an example of a “3” would be a particular user story, an example of a “5” would be this, and so forth for each of the ratings. Continue reading