The way I see it there are three aspects of a software projects that are worth noting, (or at least that I will focus on in this blog post):

1. The technical aspect

2. The process aspect

3. The meta techincal aspect

The technical aspect are all the aspects that every developer (hopefully) knows, like the programming language, the framework, the application servers etc.

The process aspect is the stuff like scrum, kanban ,lean etc.

The meta technical stuff is what I’ll zoom in on now.

First of all I’m not sure this it the best term, and probably someone has coined a better one…

However the way I see it these three aspects has to be in place for a project to suceed. The first two are usually in place, the first handled by the developer and the second by the project manager or scrum master or someone in similar roles.

However I see the last aspect often being neglected.

The meta technical aspect is about the framework of doing the technical stuff. so I would say it is for instance:

-TDD (BDD)

- SOLID

- IOC

So I would describe it as all the technical stuff that many hardcore developers do not care that much about, but that makes the quality of the code higher, and makes the code more maintainable.

The problem is that many people going into software development care about technical stuff, and care about breaking that small technical problem. But they don’t find the meta technical stuff as interesting.

I just did the string calculator kata, here is the output

[TestFixture]
    public class CalculatorTests
    {
        readonly Calculator _calc = new Calculator();
        [Test]
        public void Add_WhenGiven1_ShouldReturn1()
        {
            int result = _calc.Add("1");
            Assert.That(result, Is.EqualTo(1));
        }

        [Test]
        public void Add_WhenGiven15_ShouldReturn15()
        {
            int result = _calc.Add("15");
            Assert.That(result, Is.EqualTo(15));
        }

        [Test]
        public void Add_WhenGiven1comma5_ShouldReturn6()
        {
            int result = _calc.Add("1,5");
            Assert.That(result, Is.EqualTo(6));
        }

        [Test]
        public void Add_WhenGiven115comma23_ShouldReturn138()
        {
            int result = _calc.Add("115,23");
            Assert.That(result, Is.EqualTo(138));
        }

        [Test]
        public void Add_WhenGivenAlphaCharacter_ShouldThrowArgumentException()
        {
            Assert.Throws<ArgumentException>(() => _calc.Add("jens"));
        }

        [Test]
        public void Add_WhenGivenAlphaNumericCharacterWithNumericAtTheEnd_ShouldThrowArgumentException()
        {
            Assert.Throws<ArgumentException>(() => _calc.Add("jens1"));
        }

        [Test]
        public void Add_WhenGivenAlphaNumericCharacterWithNumericAtTheBeginning_ShouldThrowArgumentException()
        {
            Assert.Throws<ArgumentException>(() => _calc.Add("1jens"));
        }
    }

public class Calculator
    {
        public int Add(string s)
        {
            if(!Regex.IsMatch(s, @"^\d+(,\d+)?$"))
                throw new ArgumentException("s");

            var numbers = s.Split(',');
            int returnValue = 0;
            foreach (var number in numbers)
            {
                returnValue += int.Parse(number);
            }
            return returnValue;
        }
    }

Uncle Bob om software projekter:
"Tit haster vi igennem for at blive færdige til tiden, og sjusker for at gøre det hurtigere.

Men når vi sjusker os igennem opdager vi tit,  at det sjusk vi lavede for at blive hurtigt færdig,

er det der forsinker os og gør at vi bliver forsinkede."

I just discovered shelfari.com

It is a place to keep all your book information, like which books have you read, which do you like.

It's really slick and looks nice.

Here's my entry:

http://www.shelfari.com/khebbie

By the way I even added a widget to this blog, where you can see my books. I got the widget from http://www.dscoduc.com/post/2008/08/01/Shelfari-Widget-for-BlogEngineNET.aspx

I read a good blog post the other day (http://softwarecraftsmanship.oreilly.com/news/2008/8/8/uncle-bob-on-craftsmanship-at-agile-2008)

It was a comment on a statment by Uncle Bob:  "Craftmanship over crap", but in the above mentioned blog post Dave Hoover modified the statement to "Craftmanship over heroics".

I have really taken this statement in, since it speaks to me.

So let me explain to you what it means to me:

Imagine having a carpenter work on your roof, while he works for you, you think it takes a lot of time. And furthermore repairing the roof is rather expensive.

So you talk to the carpenter and tell him that its taking too much time and its too expensive.

He says: "OK, I'll help your out, I'll cut 2 days off and some materiel costs as well"

Great your are satisfied, you have a good skilled carpenter (a craftman you think) who suggest he will get finished earlier and at a lower price. He is a real hero in your eyes!

So he finishes, you pay and everyone is happy.

Now a few years later there's a big storm and its raining.

Suddenly water is dripping down in your livingroom and kitchen.

So you call the carpenter and ask him what is wrong.

He replies: "Oh!, don't you remember we cut off two days? Well I didn't put on any roofing underlay, since it would take me two days, and the material costs as well, don't you remember we agreed on that?".

Naturally at this stage your are stunned, you thought you were working with a professional (A craftman), and then he chooses to do something like that !(trying to be a hero, but now he's not!)

Well this is a very strong analogy to the business of IT, there are lots of things (actually most of the things we do) that our customers don't understand, and hence they try to push us and make us cut the price.

So the question is are we going to not put in the roofing under lay, nobody will know - well at least not right now.

But when you cut corners here you are going to end up with being in big trouble.

So choose craftmanship over heroics.

I added a link to "Programmer Competency Matrix" a few days ago and have thought a bit about it :

Well all these skills are very fine, and you should strive to get them.

BUT don't forget that people do not want good looking and well crafted software.

People want something to help them solve their problem.
Look at twitter - a very successful service - but not very well crafted...
So to be a good developer you need to understand peoples need, and put that above your urge to create beautiful code...

But still you need to maintain that code in the future.

And you still might be successful and hence be able to scale (which seems to be the problem with twitter)

I read a few blog posts and saw one video regarding the subject of this post:

1. Jeff Attwood

2. Scott Hanselman

3. Jean-Paul S. Boodhoo posted a link to a youtube video on passion

What i sum up from this is, the people with blogs are not always the most skilled, they are the most loud.

So in a company you might have to programmers: a skilled and not very loud  programmer and a not as skilled but loud programmer.

The last one it the one most likely to have a blog, but he is also not the most skilled.

So the problem is that the web  is flooded with blog posts from loud but not most skilled programmers. But when you search for answers for your problem you get answers from loud programmers.

What James Ray says in the youtube video is that the most passionate people are likely to be the most successful.

But aren't the most passionate the most loud?

So i attented the Aarhus .net User Group the other day.

Henrik Lykke Nielse of Captator gave an introducion to most of the updates to .net framework 3.5 and C# 3.0.

Most of it was known to me - however one thing that I had not heard about before was partial methods.

Partial methods are methods where you define the declaration of the method in one part of a partial class( a bit like C++ header files) and maybe choose to implement it in another part of the partial class. I say 'maybe' since you can choose to not implement the partial method, and if so all calls to the method is simply erased.

"So what good is this?", I thought to myself and asked Henrik. To this he responded that for instance you can implement functionality without thinking about instantiating classes.

Let me explain: One could do similiar stuff by making virtual methods, but the framework would then have to depend on factories and such to instantiate the correct objects for you.

However if you declare a partial method in the framework, and let be up to the user of the framework to implement the partial method or not - you get rid of all the factory fuzz.

Nice trick I think!

I just saw a program on the TV, there was a mother with three children who walked many kilometers to the hospital, because she and her children were sick to dead

Now here is the quiz why were they sick:

1. They ate too much candy and fat food
2. They excercised too little
3. They drank from the water

Many danish people are too fat and have diabetis II, now here's the second quiz, why are they sick (Two correct answers):

This morning I just realized that even I wouldn't hit my own blog when searching the internet. When I search for solutions to problems and the like, i search in english since this is the most used language on technical topics.

Hence I now switch language on my blog - to increase discoverability.