The Coder's Perspective

What I look for in a company

2013-04-17T13:18:00.002+02:00

Just a quick post on some things that are important to me. What do I look for in a company that I work for?

As little chaos as possible.
A fun, social, friendly environment...
... where people can still have some quiet time and focus.
Working with clever people.
Working with motivated people.
Rewards - especially seeing your work go "live".

Run Harder and Easier

2013-01-27T09:33:00.001+02:00

I like this advice from Active.com. It's in line with how I'm training at the moment:

The principle, "make your easy days easier and your hard days harder," couldn't be truer. But most runners tend to stay in the middle and do most of their runs at a moderate effort. They're missing out on a crucial way to improve running endurance when it's most responsive to training adaptations.

Let's start with easy runs. It's critical that your easy runs are truly easy. To keep yourself honest, it can be helpful to wear a heart-rate monitor to ensure your heart rate stays low enough to qualify as easy. The easy run is not meant to help you gain fitness. It's simply in your schedule to add a little bit of mileage and promote recovery.

With harder workouts, many runners don't put forth the effort they need to maximize fitness gains. Instead, they start to feel fatigued and cut the workout or slow their pace. In effect, they’re moving the difficulty of the workout closer to a moderate level. The next time you run a hard workout, make it exactly that—hard.

Balance the demands of your training program, and utilize these training strategies to get more endurance, speed and overall fitness from your workouts. You don't have to always train harder—you just have to train smarter to run faster.

Posted via email from The Coder's Perspective

Remember to build a log viewer page

2012-06-26T14:51:00.001+02:00

Lesson number 1: if you're building a website, be sure to be log any oddities and errors to a log file. That's easy enough. It's absolutely critical when you need to debug issues in a live system. We use NLog and it works great.

But that's not enough.

Lesson number 2: you probably won't have direct access to the live server and your precious log files, so remember to build a log file viewer page, or at least a page that allows you to download log files. (Obviously you want to restrict this to Administrator users only.) Log files are pretty useless if it takes a day to get the IT administrator to mail them to you. The turn-around time is just too slow.

Posted via email from The Coder's Perspective

Why integration tests are awesome

2012-06-25T10:20:00.001+02:00

I've spent the last month continuing work on a project that was started by someone else. So it didn't have integration tests from the start.

If you have ever written integration tests you know that a lot of effort goes into them and that they are very difficult to add midway through the project.

So I have continued development and have not started to create an integration test suite... yet.

But last week I once again realized why integration tests are so useful: I spent a fair amount of time fixing bugs that were introduced by other bug fixes. Naturally they were in unrelated parts of the system - places I wouldn't imagine things to break, so the bugs weren't detected during my development testing.

Fortunately they were detected in the UAT testing stage, so none of them will go live. But if testing wasn't as thorough...

Integration tests definitely lead to a better quality product. And they let me sleep better at night.

Posted via email from The Coder's Perspective

Debugging a weird 403.14 error in an MVC application

2012-06-20T15:57:00.001+02:00

I was getting a very strange "HTTP 403.14 Directory Listing Denied" error in my ASP.NET MVC3 application.

The strange thing was that I was only getting this for a part of my site; most of the site still worked fine.

I got the error whenever I tried to access the /Partners/ controller. Folder rights in the file system were correct. The controller did exist. Yet I kept getting this error.

Turns out the problem was a deployment of front-end files that went wrong. Instead of copying a view file into /Views/Partners/ I copied the /Partners/ folder to the root of my website. So the structure was:

/root/Partners/

/root/Views/Partners/

That first (incorrect) partners folder was confusing the hell out of MVC. I deleted it and the problem went away.

Posted via email from The Coder's Perspective

Pros and Cons of using an ORM

2012-06-19T08:50:00.001+02:00

I've been having loads of second thoughts lately about using ORMs. Do they cause more problems than they solve?

So Samuel Goldenbaum, whom I've done some work, shared some pro's and cons with me. I asked if I could blog his thoughts because they are insightful:

1. Most NB is that allows you to focus in entities and not the persistence implementation. i.e. do I need to care how something is saved within the underlying provider – and do I need to care about that for all the different providers I will use? I want to say _session.Save(myOrder) and move on to other domain concerns.

2. Huge cutdown on code write

3. Abstract your db – allows you to switch between db’s pretty easy. You write the same set of code. Also think about your dev environment – you can run super-fast sqlite for development – more nb when doing TDD, and also not be concerned about licences for everyone to have copies of SQL.

4. Abstract your db instances – allows you to write the same set of code to access multiple db instances. You may have a situation where you have MySql instances for some readonly denormalized data yet also have a large MS SQL server for core transactional stuff, and maybe even a Firebird or Postgresql instance. MS SQL is pricey these days.

5. Entity tracking – how else would you track changes to entities? All built in.

6. Cascading updates/deletes.

7. Entity navigation and eager loading entities i.e. Order.OrderLines.First().Product.Category.Name.

8. Powerful query language – lookup things like Futures and Transformers in NH

9. Fits in with TDD/DDD smoothly

10. Makes refactoring MUCH easier – esp when able to avoid “magic strings”

Cons:

1. Like anything, additional learning curve

2. Bulk updating is not great – but can be tweaked to improve performance

3. ?

Posted via email from The Coder's Perspective

The Extract and Override pattern

2012-05-14T21:06:00.001+02:00

I'm in the process of reading Roy Osherove's book, "The Art of Unit Testing". It's a great book - recommended for both Gurus and N00bs; I've learnt a couple of new things.

One of those ideas is the "Extract and Override" pattern. It is a dependency breaking technique described in "The Art of Unit Testing", but I think the name stems from Michael Feather's book, "Working Effectively with Legacy Code".

I'll describe the scenario where this pattern can help. Imagine you need to unit test a class, BookingManager. You specifically want to test the MakeBooking method. Note how the MakeBooking method depends on other methods and those methods use external dependencies:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

	public class BookingManager
	{
		public BookingWebService BookingWebService { get; set; }
		public BookingAuditingService BookingAuditingService { get; set; }
		public PartnerProgram PartnerProgram { get; set; }
		public BlacklistChecker BlacklistChecker { get; set; }

		public BookingResponse MakeBooking(Guid travelerId, Guid serviceId, int personsTraveling, DateTime dt)
		{
			if (!TravelerIsValid(travelerId))
			{
				return new BookingResponse(false, "Traveler is invalid, unable to continue. View audit logs for more details");
			}

			if (dt > DateTime.Now)
			{
				BookingWebService.RecordBooking(travelerId, serviceId, personsTraveling, dt);
				LogTravelRewardInfoWithPartner(travelerId, personsTraveling, dt);
				return new BookingResponse(true, "Success.");
			}
			else
			{
				return new BookingResponse(false, "Booking date was in the past.");
			}
		}


		private void LogTravelRewardInfoWithPartner(Guid travelerId, int personsTraveling, DateTime dt)
		{
			using (PartnerSession partnerSession = PartnerProgram.OpenSession())
			{
				partnerSession.RecordRewardInfo(travelerId, personsTraveling, dt);
			}

			BookingAuditingService.WriteAuditEntry("Recorded log travel reward with partner service.");
		}


		private bool TravelerIsValid(Guid travelerId)
		{
			if (!BookingWebService.TravelerIsActive(travelerId))
			{
				BookingAuditingService.WriteAuditEntry(string.Format("Traveler {0} was inactive. BookingManager should not have been called.", travelerId));
				return false;
			}

			if (BlacklistChecker.TravelerIsBlacklisted(travelerId))
			{
				BookingAuditingService.WriteAuditEntry(string.Format("Traveler {0} was blacklisted. BookingManager should not have been called.", travelerId));
				return false;
			}

			return true;
		}
	}

What the Extract and Override pattern allows is for you to test the MakeBooking method in isolation, without the all the logic and external dependencies in the other methods it depends on. You extract a sub class from the class under test, and *override* the methods you don't care about. Those method can return predefined values. Like so:

1 2 3 4 5 6 7 8 9 10 11 12

	public class BookingManagerTestMakeBooking : BookingManager
	{
		protected override void LogTravelRewardInfoWithPartner(Guid travelerId, int personsTraveling, DateTime dt)
		{
			//All good.
		}

		protected override bool TravelerIsValid(Guid travelerId)
		{
			return true;
		}
	}

We had to mark the methods we are overriding as virtual. The test can create an instance of THIS class instead of the actual class, but it will still test the actual MakeBooking method. The methods our MakeBooking method depends on are stub methods - they simply succeed.

This pattern helps you to isolate the method you want to test from other methods in the same class under test. Pretty useful!

Posted via email from The Coder's Perspective

The Extract and Override pattern

2012-05-14T13:17:00.001+02:00

I'm in the process of reading Roy Osherove's book, "The Art of Unit Testing". It's a great book - recommended for both Gurus and N00bs; I've learnt a couple of new things.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55

	public class BookingManager
	{
		public BookingWebService BookingWebService { get; set; }
		public BookingAuditingService BookingAuditingService { get; set; }
		public PartnerProgram PartnerProgram { get; set; }
		public BlacklistChecker BlacklistChecker { get; set; }

		public BookingResponse MakeBooking(Guid travelerId, Guid serviceId, int personsTraveling, DateTime dt)
		{
			if (!TravelerIsValid(travelerId))
			{
				return new BookingResponse(false, "Traveler is invalid, unable to continue. View audit logs for more details");
			}

			if (dt > DateTime.Now)
			{
				BookingWebService.RecordBooking(travelerId, serviceId, personsTraveling, dt);
				LogTravelRewardInfoWithPartner(travelerId, personsTraveling, dt);
				return new BookingResponse(true, "Success.");
			}
			else
			{
				return new BookingResponse(false, "Booking date was in the past.");
			}
		}


		private void LogTravelRewardInfoWithPartner(Guid travelerId, int personsTraveling, DateTime dt)
		{
			using (PartnerSession partnerSession = PartnerProgram.OpenSession())
			{
				partnerSession.RecordRewardInfo(travelerId, personsTraveling, dt);
			}

			BookingAuditingService.WriteAuditEntry("Recorded log travel reward with partner service.");
		}


		private bool TravelerIsValid(Guid travelerId)
		{
			if (!BookingWebService.TravelerIsActive(travelerId))
			{
				BookingAuditingService.WriteAuditEntry(string.Format("Traveler {0} was inactive. BookingManager should not have been called.", travelerId));
				return false;
			}

			if (BlacklistChecker.TravelerIsBlacklisted(travelerId))
			{
				BookingAuditingService.WriteAuditEntry(string.Format("Traveler {0} was blacklisted. BookingManager should not have been called.", travelerId));
				return false;
			}

			return true;
		}
	}

1 2 3 4 5 6 7 8 9 10 11 12

	public class BookingManagerTestMakeBooking : BookingManager
	{
		protected override void LogTravelRewardInfoWithPartner(Guid travelerId, int personsTraveling, DateTime dt)
		{
			//All good.
		}

		protected override bool TravelerIsValid(Guid travelerId)
		{
			return true;
		}
	}

This pattern helps you to isolate the method you want to test from other methods in the same class under test. Pretty useful!

Posted via email from The Coder's Perspective

Published Interface

2012-05-04T16:37:00.001+02:00

Martin Fowler defines a Published Interface as a class that is used outside the code base it is defined in. It's more public than public. I think we need a keyword for this in C# (veryPublic? :).

Here's Martin's post: http://martinfowler.com/bliki/PublishedInterface.html

Posted via email from The Coder's Perspective

Handling error: "401 - Unauthorized: Access is denied due to invalid credentials"

2012-05-04T14:46:00.001+02:00

I struggled with an error from IIS after copying a website from one server to another: "401 - Unauthorized: Access is denied due to invalid credentials"

The website app pool identity was set to ApplicationPoolIdentity, and that user had full rights to the physical folder path. So I had no idea why I would be getting permissions errors.

Finally my colleague, Richard, helped me figure out that assigning rights to the AppPool user was not enough. You also have to give folder rights to the local IUSR account. Note that this is different from the IIS_IUSRS account.

Lovely.

Posted via email from The Coder's Perspective

Long running integration tests

2012-03-15T12:44:00.001+02:00

I'm typing this blog post while waiting for our integration tests to finish executing. For this project the tests take about 15 minutes to complete. There are 178 integration tests.

I love the fact that the integration tests run several times a day. But I hate how long it takes to get my work integrated into the main branch (Edge/Trunk) of our repository.

If integration tests fail once or twice, it means integrating can take as much as two hours.

I wonder how other people feel about running integration tests as part of the build. Is it a good idea? Or a bad one?

I think it's definitely great for quality. It's just a pain in the ass.

Posted via email from The Coder's Perspective

Thoughts about software projects

2012-03-09T19:07:00.001+02:00

Software projects are risky. So plan to deliver a week or two earlier than the deadline. Yes, I know it feels like you will "waste" that week or two and that you won't be 1-billion percent productive. Trust me - you won't be wasting that time. There's always loads more to do. Unexpected things always happen once you release to the "Production" server.

Software projects are risky. Shit happens. So play it safe. Release early. Then do lots of UAT.

Posted via email from The Coder's Perspective

Code Snippet: Method to convert Variable sized list to a fixed size array

2012-03-07T14:25:00.001+02:00

I wrote this bit of code that takes a List<String> (variable size obviously) and converts it to an array of specified size as requested by the caller.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

/// <summary>
/// Takes a list of any size, and an int specifying how large the resulting array should be,
/// then fits the items of the list in the array. Concatenating more than one item in a single
/// array index with a comma.
/// </summary>
private static string[] VariableSizeListToArrayOfFixedSize(int requiredFixedSize, IList<string> sourceList)
{
	var destinationArray = new string[requiredFixedSize];
	int minNrOfItemsPerLine = sourceList.Count/requiredFixedSize;
	var listItemQueue = new Queue<string>(sourceList);
	int destIndex = 0;

	//Populate resultArray one item at a time.
	while (destIndex < requiredFixedSize)
	{
		if (listItemQueue.Count == 0)
			break;

		string line = listItemQueue.Dequeue();

		//If each line item receives more than one item from the queue, loop here
		//	and add list items to the current line item (concat with ',').
		for (int batchCount = 1; batchCount < minNrOfItemsPerLine; batchCount++)
		{
			if (listItemQueue.Count > 0)
				line += ", " + listItemQueue.Dequeue();
		}
		destinationArray[destIndex++] = line;
	}

	//If there are still items left in the list. Append remaining items to 
	//	last item in the array.
	foreach (string listItem in listItemQueue)
	{
		destinationArray[destinationArray.Length - 1] += ", " + listItem;
	}
	return destinationArray;
}

Useful. And fun to write. Especially since I had loads of Unit Tests checking that I didn't break anything while refactoring quite aggressively.

Posted via email from The Coder's Perspective

Reflection: I'm a versatile person

2012-02-17T07:33:00.001+02:00

We can be so hard on ourselves, so it's nice to take a step back and think about what we do well.

I'm going to take advantage of my own blog and do a little bragging today. In relation to my job, I am actually a very versatile person.

I code nice front-ends.
I code advanced back-ends.
I'm good at Debugging weird issues.

But I'm more than just a code monkey. I also do the following things pretty well:

I'm organized - I get things done.
I write well - proposals and blog posts.
I do presentations.
I design.
I'm professional and friendly when I deal with clients.
I even do network admin stuff.

That's a lot to be proud of I think.

There are some things that I'm not so good at though, but practice makes perfect:

Coordinating a project
Dealing with project politics
Fighting with managers and clients (i.e. pushing back against unrealistic expectations)
Handling too much pressure

Posted via email from The Coder's Perspective

Different kinds of viruses/virii

2012-02-15T08:38:00.001+02:00

A colleague, Justus, described the different kinds of viruses/virii to me. Interesting stuff...

A Trojan - opens a "back door" into your system. Just like the story about the Trojan Horse.
A Worm - propagates aggressively across your system and the network.
A Rootkit - the most advanced. Attaches itself onto the operating system kernel and hides itself. Very difficult to detect and very dangerous.

Nasty little fuckers.

Posted via email from The Coder's Perspective

An interesting difference between the ASP.NET Dev Server and IIS

2012-02-01T14:25:00.001+02:00

By default IIS will not return static content like CSS and JS files through the ASP.NET pipeline. So Global.asax won't be invoked.

But on the ASP.NET Dev server all files, including CSS and JS files, will go through the ASP.NET pipeline. So Global.asax will be invoked.

Remember this when you're profiling your application! It can lead to skewed results.

Posted via email from The Coder's Perspective

Skyrim first impressions

2012-01-27T07:53:00.001+02:00

So I started playing Skyrim last night and I have to say: What a Treat!

I spent a lot of time looting and enjoying the scenery. I only played for two hours, but in those two hours I felt like I was in a different world entirely. The game really sucks you in. I love the frigid landscape, the mountains and the waterfalls; it feels like you're in Beowulf.

But what I really appreciate is the slick menu system. You can see that Bethesda put a lot of effort into the menu. I find it interesting how they use typography (mostly font size actually) and subtle icons to indicate what's active on the menu and what's important. Most other games seem to go the garish-background and border-overload route to compartementalize the user interface. So I really like how Bethesda did Skyrim's menu. Very well done.

I will probably spend this weekend in my underwear playing more. Looking forward to it :)

Posted via email from The Coder's Perspective

How to cure hiccups?

2012-01-26T07:15:00.001+02:00

This "swallow method" from wikiHow did the trick for me. No more hiccups, thank goodness...

Breathe in as far as you can.
Swallow without letting any air out.
Breathe in more, as far as you can. Do not let any air out!
Repeat steps two and three as many times as possible. When you feel you can't swallow anymore, swallow again. You may turn red and make squeaking noises, but keep swallowing and inhaling.
When you absolutely can't swallow anymore, exhale all the way.
Your hiccups will be gone!

Posted via email from The Coder's Perspective

How using an Agile process combats the common project pitfalls

2012-01-19T08:04:00.001+02:00

Software projects are packed chock-full of Risk. It's important to acknowledge the risks and to mitigate them. How you address the risks depends on which type of "project process" you are following. The two types of project processes that I have experienced are Agile-type and Waterfall-type projects. In this post I list some of the common ways to mitigate well-known risks for both these project types.

When given a choice we prefer to adopt an Agile approach. We believe that following an Agile approach leads to a far superior final product. We also believe that Agile is much less risky. So this post is unashamedly biased in favor of Agile.

First, a brief description of the two types of projects:

Waterfall-type project:

A waterfall project typically has a set deadline for set functionality. Many businesses like this type of project because it seems predictable and makes it easy to get a budget approved for the project.

Process: Plan, Build, Test, Done.

Problems:

Trying to predict accurately while software development is very unpredictable.
User Requirements Specifications are usually insufficient and open to interpretation, which leads to errors.

Scope Creep is time-consuming to manage and often "sneaks" in due to unclear specifications. This puts pressure on the development team to deliver more functionality in the same amount of time.

Agile-type project:

An agile project is typically seen as a recurring monthly expense instead of a big capital expense. Features are delivered frequently (typically every two weeks) and the project carries on for as long as it is delivering useful functionality.

Process: Plan, Build, Test, *Repeat Repeat Repeat

Problems:

Unable to promise specific features at a specific deadline far in the future.

Difficult to work with businesses with a "waterfall" mindset (most big old businesses).
Difficult to get project approval when hard-and-fast promises can't be made.

Advantages:

Deliver what's useful, not "what the spec said".

Deliver useful features early.

Detect problems early.

Embraces change.

Why Projects Fail

Projects can be considered failures for many reasons. The most common reasons that I have observed are:

Budget Overruns and Late Delivery - these two usually go hand-in-hand.

Incorrect Functionality delivered - the client expected one thing and the programmers built something else.

Technical Problems - for example: the system is too slow to use, or it doesn't integrate with another critical system in the software ecosystem.

Below is a list of ways to combat these three problems in either a Waterfall or Agile project.

Problem 1: Budget Overrun/ Late Delivery

Waterfall:

Add extra time to mitigate risk. For example: estimate 13 hours for a 10 hour task. Not optimal. Expensive.

Track progress against milestones to ensure the project is progressing on schedule. (The problem with milestones is that they can give a false sense of security. When you think something is "Done" it might not really be. "It's done! (except for the styling, or integration with external system X)")

Work overtime if needed to catch-up.

Agile:

Frequent delivery means most important features get delivered early.
If less important features are late it is not such a big deal. The system is constantly improving and maturing.

Problem 2: Technical Problems

Waterfall:

Do lots of prototyping in the first stage of the project to try and spot technical challenges.

If caught late it may be too late to do anything about it. Major losses.

Agile:

Will be picked up early due to continuous early delivery. Project can then go a different direction, or cancel project if absolutely necessary (at least it will be early).

Problem 3: Wrong Functionality (incorrect assumptions)

Waterfall:

Write very detailed user requirements specification. (The problem with User Requirements is that they give a false sense of security. Now matter how explicitly they are written, they are still open to individual interpretation and interpretation may not be what the author intended.)

If caught late it may be too late to do anything about it. Major losses.

Agile:

Agile embraces change. Frequent delivery ensures that the correct functionality is delivered and any "mistakes" are detected early. The client is continually evaluating the system and can change direction as required.

Posted via email from The Coder's Perspective

Why I love my job reason nr 49...

2012-01-10T14:28:00.001+02:00

I don't have to work with ASP.NET WebForms anymore!

That deserves lots of exclamation marks!!!!! !!!! !!!!

ASP.NET MVC3 is such a pleasure.

Posted via email from The Coder's Perspective

Why I love my job reason number 48...

2012-01-10T13:55:00.001+02:00

The website I am working on only caters for English speakers. What a pleasure! Localization is such a pain.

Posted via email from The Coder's Perspective

Code Snippet: Show a message when a user is using an old browser.

2012-01-07T16:59:00.001+02:00

For my personal project I would like to show a message to the user if the user is using an old browser. This is mainly because I don't want to spend time testing all the old browsers. I'd rather just tell the user that the site works better on certain browsers and give him the links to download the browser of his choice.

Thankfully JQuery makes this ridiculously easy. Here is the code...

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

<div class="works-best-on hidden">
    This web application works best on a modern browser like <a href="https://www.google.com/chrome">Chrome</a>, <a href="http://www.mozilla.org/en-US/firefox/new/">Firefox 4+</a> or <a href="http://www.microsoft.com/ie9">Internet Explorer 8+</a>
</div>

<script type="text/javascript">

    $(function () {
        if (badBrowser()) {
            $(".works-best-on").show("normal");
        }

        function badBrowser() {
            if ($.browser.msie && parseInt($.browser.version) <= 7) { return true; }
            if ($.browser.mozilla && parseInt($.browser.version) <= 3) { return true; }
            return false;
        }
    });
    
</script>

Posted via email from The Coder's Perspective

I'm proud to be a software developer

2012-01-06T10:08:00.001+02:00

It's easy to get stuck in a rut and disregard the big picture. The big picture is that as a software developer I get to build ridiculously complicated machines with an insane amount of components that interact with one another. And a software machine is so flexible that I get to make changes very easily. The machine can be reconfigured with a couple of keystrokes, tested, broken, fixed, several times a day.

This is a pretty amazing job.

Posted via email from The Coder's Perspective

Apples Painting

2011-12-30T10:21:00.001+02:00

Initially I was feeling discouraged about these bloody apples. But in the end I'm very happy with how the painting turned out. This is my first still-life painting and painted from life instead of a photo. Fun :)

12"x16"

Oil on Canvas Panel

Posted via email from The Coder's Perspective

Suddenly getting HTTP404 on your ASP.NET website?

2011-12-19T09:05:00.001+02:00

Was your website working fine yesterday, but today you get an HTTP404 exception?

Check your disk space. Our drive had 0 bytes free space on C. After freeing some space the problem was resolved.

Posted via email from The Coder's Perspective