Wednesday, May 20, 2015

Windows 7 Outlook issue: "ost is in use and cannot be accessed".

I got to work early today, ready to get to work, and was greeted with this cheery note from my Windows 7 box when opening Outlook:

"The file C:\Users\username\AppData\Local\Microsoft\Outlook\username.ost is in use and cannot be accessed. Close any application that is using this file, and then try again. You might need to restart your computer."

Restarting the box did not help. I had to open the "Windows Task Manager" (Ctrl-Shift-Esc), select "Lync.exe" and kill it (you might also need to kill "Communicator", "ucmapi", or "Outlook" itself). Then Outlook was happy and I could start my day.

This morning's ambush reminds me of Cato hiding in wait for Inspector Clouseau to return so Cato can attack him, just to keep Clouseau sharp.

Friday, May 15, 2015

Testing .Net C# WebAPI methods with NUnit and HttpResponseMessage

I recently wrote my first NUnit test for a .Net WebAPI controller. I learned two interesting things. (The code has been simplified to be more explicit).

1. When you create your controller, set a value for it's "Request" object.

//helper function to create testable "projects" controller
private ProjectsController GetTestProjectsController()
{
    ProjectsController controller = 
         new ProjectsController(logger, new ProjectRepository())
    {
        Request = new HttpRequestMessage()
        {
            Properties = { { HttpPropertyKeys.HttpConfigurationKey, 
                 new HttpConfiguration() } }
        }
    };
    return controller;
}

2. When retrieving an object use the TryGetContentValue() method to extract the returned value as a C# object. Notice on line 18 we free the C# object from the clutches of the evil HttpResponseMessage object.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
[Test]
public void GetTestWithExistingProjectName()
{
    string projectName = "GetTestWithProjectName";
    var projectRepository = new ProjectRepository();

    // Arrange
    DeleteProjectIfItExists(projectRepository, projectName);
    var newTestProject = CreateNewTestProjectAndWriteToRepository(projectName,projectRepository);
    var controller = GetTestProjectsController();

    // Act
    HttpResponseMessage httpResponseMessage = controller.Get(projectName);

    // Assert
    Assert.IsTrue(httpResponseMessage.IsSuccessStatusCode);
    Project project = null;
    httpResponseMessage.TryGetContentValue(out project);
    Assert.AreEqual(projectName, project.Name);

    //cleanup
    DeleteProjectIfItExists(projectRepository, projectName);
}

This is the code for the api GET.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
public HttpResponseMessage Get(string name)
{
    var project = _projectRepository.GetProjectByName(name);
    if (project != null)
    {
        return Request.CreateResponse(HttpStatusCode.OK, project);
    }
    return Request.CreateErrorResponse(HttpStatusCode.NotFound, 
            "Sorry, the project '" + name + "' could not be found.");
}

Special thanks to the folks at hilite.me for their awesome code highlighter site.

Tuesday, April 21, 2015

The Power of Culture and Public Education

I watched a documentary about Able Archer, the 1983 NATO exercise that was misunderstood by the Soviets, who almost launched a full scale nuclear strike.

One of the most interesting parts was an interview with an older Soviet women. She could not understand why all the world wanted to destroy her beloved Russia which was only trying to bring a better way of life to the oppressed.
Here was a women living in the "Evil Empire", an empire that invaded countries without provocation, routinely used torture, had a vast surveillance state, had secret courts with secret trials, overthrew democratically elected governments, and was run by an elite for the elite.

Yet since she had grown up with the state education, watched the national news and was surrounded by her culture, she thought Russia was the "Good Empire".

Friday, March 13, 2015

A Human Colony on Mars?


One of the issues in starting a Mars colony that hasn't had a lot of press is this: "Can humans survive in 38% of earth's gravity?" Astronauts staying aloft in the International Space Station for extended periods have many physical issues like eye problems.
We spend a lot of time and money planning on sending people to Mars to preserve our species without thinking if humans could even survive there for a few years.

But for the long term survival on Mars, the big question is whether a human fetus can develop normally in 38% gravity to maturity. I doubt it. Many, many questions need to be answered, like "Since Martians would probably be taller with thinner bones, would the volume of marrow make the appropriate amount of blood?"  

We need to fund something like the Mars Gravity Biosatellite before spending any more money on a manned trip to mars.  We put mice with food and water in a 55 gallon drum, set it in low earth orbit and set the drum spinning so the mice experience .38% earth gravity.  Have a live video cam to watch their progress and let's see if the mice can reproduce two generations.

This needs to be done before spending any more effort on a manned Mars expedition.  I personally would rather NASA be spending our precious dollars on sending robotic space craft to all the moons in our solar system instead of a project which may be doomed from the start. (see Scotland's failed colonization of Panama for an example of spending a fortune without proper planning).


Json.NET Error: Could not create an instance of type IAmAnInterface

While using NewtonSoft's excellent Json.NET library, I was trying to deserialize a dictionary containing interface objects and got this error message:

"Could not create an instance of type IAmAnInterface. Type is an interface or abstract class and cannot be instantiated. "

Fortunately Json.NET has a very easy way around this by telling it to save the type metadata in the output.  To serialize the dictionary:



        static readonly Object Locker = new object();
        public void Save()
        {
            lock (Locker)
            {
                File.WriteAllText(reportFilePath,
                    JsonConvert.SerializeObject(_dictionary, Formatting.Indented, new JsonSerializerSettings
                    {
                        TypeNameHandling = TypeNameHandling.Objects,
                        TypeNameAssemblyFormat = System.Runtime.Serialization.Formatters.FormatterAssemblyStyle.Simple
                    }));
            }
        }


To bring the objects back:

         public void Load()
        {
            _dictionary = JsonConvert.DeserializeObject>(File.ReadAllText(reportFilePath),
                new JsonSerializerSettings
                {
                    TypeNameHandling = TypeNameHandling.Objects
                });
        }



This does make the json file larger, but for us, it's well worth the price.






Saturday, February 07, 2015

How Governments Secretly Borrow from Employees

While talking with my Dad about his time in the Air Force, he mentioned that during the Vietnam War, wages for pilots were a fraction of what commercial pilots earned. He said the understanding was that the pay was low now, but you can retire early with a great pay in 25 years.

Friends who work for the city of Austin echo this sentiment as well - the pay for city employees is lower than the private sector, but the retirement is great - good monthly checks and subsidized health care.

What the government is actually doing is covertly borrowing money from its employees.

Promising hefty retirement benefits for low pay now is bad for because it masks the true cost of the government, so people don't know how terrible the public finances are.

Friday, January 23, 2015

Estimating Sprint Story Effort with PlanningPoker.com

For our next sprint, our Argentinian developer suggested we use Mountain Goat's www.PlanningPoker.com to do our story estimation. To my surprise, using it was very easy. I had an account in 30 seconds (thanks Ken for not making me retype my password when creating an account - that always annoys me - if I mess it up I'll do the "forgot password" link). I emailed our team members the link that PlanningPoker gave me and we were off and running.

I was a little skeptical that it would be worth our while, but estimating was easier using the tool.
I'd recommend it.  We didn't create a story entry for each story, just used the first one and then overlaid a list of stories entered into emacs on the webex screen, everyone discussed the story and we re-voted on the "original" one.  The stories will then go into Jira with the estimated effort.
Best of all it's free.