The software aria

Clean Code chapter 5 questions - Formatting

2009-04-05T21:02:00.618+02:00

This blog post is part of a series of blog posts concerning a Clean Code study circle that we developers at Admeta are persuing during 2009. Here you can find an introduction concerning the question why we are doing this and here you can find an overview of all chapters as well as some study circle recommendations.

Chapter 5 Formatting questions:

Coding Convention conventions:

How many characters per line do you think is maximum?

What resolution do you use on your monitor?

How do you typically choose to group code in your classes?

Do you place a caller and callee method close to each other or group them in some other way

Where do choose to declare your member variables?

Design considerations:

Do you agree with that "protected variables" should be avoided? Why / Why not?
How many rows do you think a class can have before your warning bell start to ring that it might be too big and do too much?
Is there any reason you can think in which instance variables should be placed anywhere but at the top?

Questions to ponder upon:

The chapter

emphasizes quite a lot on grouping code together that belong together. (Vertical Density p79, and Conceptual Affinity on p 84)

What different group categories do you use and why?
Where do you draw the line between grouping code with regards to functionality in a class and extracting a group to a new class (according to the Single Responsibility Principle)

Do you agree upon that all developers in the team should agree on single

formatting rules.

Where do draw the line of agreement?
How do you select which rules to apply? Voting or something else?

What on earth is a ”Hollerith limit”? :-)

Clean Code chapter 4 questions

2009-03-15T19:16:56.796+01:00

Chapter 4 Comments questions:

Reading quiz:

What does Robert Martin mean when he writes that comments lie?
This chapter contains 8 different categories of good comments. Which ones do you remember?
Likewise there are 18 categories of bad comments. Which ones do you remember?
Chapter 17 "smells and Heuristics", lists 5 categories of bad comments (p.286)

Questions to ponder upon:

One good comment is the "todo comment" which has tooling support in Visual Studio.NET. There is also tool support for using the "Hack" comment (e.g. //Hack: this code should be cleaned up when there is time for it). Do you think this is a good comment to use if you don't have the time to clean the code to a good design?
Setting a function comment has the positive side effect in Visual Studio that the comment is visible with the so called Intellisense (auto-complete). However, there is a limit to how long a sentence can be in order to be showed in the intellisense. One could argue that a valid comment would need to be long in order to say anything that the function name itself does not convey. Do you agree or disagree?
What is/has been your reason for commiting commented-out code to the source code repository?
If you are implementing an algorithm that is more complex than usually, do you prefer to document that algorithm as pseudo-code as a comment close to the implementation of it? Why/why not?

The context of our study sessions is restricted to .NET and C#.

Clean Code chapter 3 questions

2009-03-02T11:46:02.866+01:00

Questions: Chapter 3 Functions

Reading quiz:

Why should functions be small?
Why do function arguments take a lot of conceptual powers?
How do you avoid too many parameters in a function?
What is temporal coupling?
When would you make a difference between returning a value from a function and setting the value as a class field within the method?

Design considerations:

Is it ok to have many different levels of abstractions within the same method / class?
How do you see C# v3 Extension Methods fit into what Robert Martin writes in this chapter?
If you don't use flag arguments, and instead use several unique methods, how do you avoid duplication in the code?
Do you see any design choice in which error codes code be used and still avoid creating a dependency magnet, as well as avoiding OCP violation?

Questions to ponder upon:

Functions are also sometimes referred to as methods (no return value). Why does not Robert Martin mention methods in the chapter?
If functions should only contain 6-8 lines, would you prefer not to waste space using {} when you have an if statement followed by a one line block statement?
Say that a function is doing several things, but these things can be considered as one thing on a higher abstraction level. How do you label that function if you can't find a good name to describe that higher abstraction layer?

The context of our study sessions is restricted to .NET and C#, thus the nature of the questions above.

Clean Code chapter 2 questions

2009-02-16T11:44:50.525+01:00

This blog post is part of a series of blog posts concerning a Clean Code study circle that we developers at Admeta are persuing during 2009. Here you can find an introduction concerning the question why we are doing this and here you can find an overview of all chapters as well as some study circle recommendations.

Questions: Chapter 2 Meaningful Names

What do you think is the characteristics of a good name?
Do you take IDE Code Completion into consideration when labeling namespaces, class names and its members?
Have you reflected upon "noise words" in names before?
If you have a class property of type int named Age, but you discover that you would actually want an Age property of type string as well. How would you handle this?
Are you or have you been using Hungarian Casing? Why? Do you agree with the books statement that it should not be used in modern languages?
Having a prefixed I for interface is an established Microsoft convention. Do you agree with this? Why?
- Extra (Design considerations): Interface vs Base classes [1], [2], [3], and [4].
Do you think "Duck Typing" is something good and do you see Duck Typing as possible in a typed language as C# v3?
- How far should we utilise the support for Duck Typing in CS 3?
Would you consider complexity of code as a beautiful thing or do you agree with the books ways of seeing such practices to write complex code deliberately as a personal quest to show off mental capabilities?
Is there any benefit of using constructor (or a static factory method that produces the object) as a way to inject dependencies compared to properties/mehtods?
Design: So you find the concept of Value Object as a useful pattern?
What is your opinion on PascalCasing and camelCasing?
- Do you have a deviating opinion from Microsofts recommendations of when to use which?
Are there any rules in Chapter 17 that you think originates from this chapter?
- Is there any rule that you are missing from what you have read in this chapter?

The context of our study sessions is restricted to .NET and C#, thus the nature of the questions above.

Clean Code chapter 1 questions

2009-02-02T11:42:38.827+01:00

Chapter 1 Clean Code questions:

Before reading, take a moment to reflect what the concept of Clean Code means to you.
- Is there anyone of the different "guru's" description of Clean Code (p7-12 + forword) that do you think lies closest to your own definition of Clean Code?
- After having read the chapter, has the reading changed your conception?
What is your experience / opinion of code generation tools or any other higher abstraction level of programming (4GL)?
- Do you have any good or bad experience of building your own code generator (in some way)?
- Where do you think we are heading when it comes to abstraction levels in languages and tools?
- Do you consider this to be a bright future for us developers?
- extra: What do you think of Joel Spolskys described "The Law of Leaky Abstractions"?
Have you experienced something like "the Grand Redesign in the Sky" and how did that end?
What is / has been your explanation to having written bad code (as we all have done!) in the past?
Do you think it is suitable for us as a team to align to a "School Of Thoughts" (p12) or do you see any better path to having a more uniform clean code conception?
What do you think of "the Boy Scout Rule" (p.14) applied to code?
Are you familiar with any or all following Principles of Design (S.O.L.I.D.) (p15):
- SRP - The Single Responsibility Principle
- OCP - The Open / Closed Principle
- LSP - The Liskov Substitution Principle
- ISP - The Interface Segration Principle
- DIP - The Dependency-Inversion Principle
What do you think is the status of Clean Code at our company?

As a side-note, Robert C. Martin and Joel Spolsky, the two people basically mentioned above, seem to be disagreeing a lot these days (excellent summary here by Niclas Nilsson). I guess they have not read my writing upon the Truth vs the Truth... :) They seem to have made up somewhat in the end though.

Clean Code study circle question overview and guidelines

2009-02-01T12:16:31.825+01:00

Reading the Clean Code book, as for reading any book really, is not just about reading and understanding. It is also about reflecting on what is stated and translate it into your own context and experience. I hope that these questions will help you do this.

In a previous post entry I wrote about my idea of starting a Clean Code study circle at work. In this blog post I will collect an overview of the book as we continue our study circle providing links to blog post containing questions for each chapter. I've also posted some guidelines and recommendations for others who are thinking of starting a study circle. I will be updating the list below with links as we go along with our study circle at Admeta during 2009.

Study Questions chapter overview

Clean Code: questions
Meaningful names: questions
Functions: questions
Comments: questions
Formatting: questions
Objects and Data Structures
Error Handling
Boundaries
Unit Tests
Classes
Systems
Emergence
Concurrency
Successive Refinement
JUnit Internals
Refactoring Serial Date

Some Guidelines for Starting a Study Circle

If you are thinking of starting a study circle at work, here’s a couple of practical advises based upon our experience:

The topics in each chapter can potentially lead to discussion that lasts for days... But try to limit yourself to the time set out for it. The meetings is not necessarily about reaching a final agreement of every discussion. Instead, look at is as the beginning of a journey to some kind of agreement of a mutual understanding of what clean code is.
During the hour, we summarize each sub chapter. I.e. some volunteer person for each subchapter summarizes in his own word briefly and objectively what was written. Once done with this, the same person gets to be the first to reflect upon the content. A discussion can follow afterwards.

For us, such a summary/discussion of the chapter would take more than an hour (in both groups). So it is a good idea to tell people in advance what subchapters they think should be focused on in each chapter. Start with these subchapters when you meet!

Most likely, you will not have time to discuss the questions. But you may sneak a question in at a sub chapter discussion.
As a follow up to the meeting, use some kind of survey tool to poll questions discussed in the meetings. This way you will actually get a statistical backing up of what people think based not only by those who are the most eloquent with words.

I tried out using SharePoint surveys but I don’t like the tool. (I might come back with a little blog post rant on this…)
If there are many developers, split the group into smaller groups. It is easier for all people to get a chance to say something if the groups are smaller. The person who set up the group will participate in both groups and act as the meeting coordinator and bridge between the two groups.

If several groups are used, I think it is a good idea to rotate the people in it every other or third meeting. Everyone should really know everyone in good working teams.

An idea of how to get a common view of Clean Code amongs developers

2009-01-31T20:35:37.403+01:00

At Øredev in November 2008, I got the opportunity to listen to Robert C. Martin, also known as Uncle Bob. I have been a fan of his work for many years ever since I read his book Agile Software Development Principles, Patterns, and Practices. A few years later when the C# version came out I took the opportunity to reread many of the chapters. To me, that book became a eye opener to a new way of working with code. And I think I am not alone. For instance, it seems to me like much of the ALT.NET movement gets a lot of inspiration from topics found in this book. Like for instance the excellent description of the 6 design principles, now commonly referred to as S.O.L.I.D.

Anyways, in 2008, Robert Martin came out with a completly new book called Clean Code: A Handbook of Agile Software Craftsmanship. Naturally, Clean code was his chosen topic at Øredev for both his keynote and the session on Functions (chapter 3). Robert Martin proved to be a passionate speaker so I was not disappointed. Neither have I been disappointed in this new book so far. Since Øredev I have read about half the book and I truly feel that it is a gold mine to read for any professional developer.

But I kind of stopped reading a couple of weeks ago since I had this great idea. But before I tell you what, I’ll tell you why. That’s usually a good start.

The big WHY

The concept of “Clean” is often defined per developer

This is a bit unfortunate but my experience is that we developers all have different opinion as to what clean code really is. We all get our little habits and our own way to keep our code clean and readable to ourselves. It happens that we shun the sight of other people’s code since it simply is not clean. As in our definition of clean that is.

If only, we could keep our noses glued solemnly into our own written code. Unfortunatly, this is not so.

The common code base

Professional programmers usually don’t work isolated from other professional programmers (although it happens). Most often you share a code base with others and you will have to dig into and work with other peoples code. This is usually where a developers' nose start sneering since, "no way, that code is clean!"

Imagine this sneering nose developers name being Robert. So what does Robert do when confronted with such ugly code? Well, he would probably sneak in a bit of refactoring of the code with the sole purpose of making it clean. That’s ok and quite normal for any programmer to do. So it should be ok.

The only problem is that when Joe, who originally wrote the code, wants to work again with the submitted, now clean, code, he finds the code to be … unclean.

What does Joe do? Well, you guessed right: refactor a bit back to “clean” state. With a big grin of proudness, Joe will resubmit the now clean code into the code repository.

Later when Robert comes back to this code, what does she do? Well perhaps refact............

Verbal Communication

Naturally, we developers aren’t idiots (although it may perhaps seem so occasionally to non-devs.) and we do have a mouth for other purposes than to shovel food and drinks into it. So in the end, Robert, or Joe, will walk over and talk to eachother. This is where the "big discussion" may start. What is clean and what is not clean code.

It may sound like it would be a heated and most dreadful debate. But I think most developers actually like discussing these things. As long as you are able to convince the other guy of how beautiful and logical your clean code is. However, most of the time, this agreement does not occur and the constant battle of Clean Code carries on.

In the end, developers may stay away from other peoples code since it is tainted by uncleanness.

The Contract

Naturally, the previous description is not a successful situation to have at a company. The code base must be shared for lots of reasons; work scalability and fresh influences to name a few. So many companies bring out code policies, written in a document for all developers to see and sign on. In blood. Code inspection tools, like FxCop, will run at night and report to everyone in the morning if someone has violated the signed contract of Clean Code.

Naturally, the contract has got to come from somewhere. There are a couple of different ways

A) The company chief architect(s) brings forth the document for all developers to follow.

B) All developers join in big battle lasting for days and come up with a final agreement.

C) The company borrows someone else’s contract.

Naturally, C) is the most common option. But there will always be room for B) and A) since there are domain specific stuff that still can be agreed upon.

The idea – the WHAT

At Admeta, where I work, we are using the Scrum project methodology and we are fairly agile in the way we work. We are using model C) as in the Microsoft conventions and guidelines and we also have a wiki page with further conventions agreed upon, i.e. B). We do not believe in the A) alternative.

So naturally when I began reading the book, it became clear to me that I would be doing an awful lot of referencing to the book when discussing clean code with my collegues. Very soon I thought, my colleagues would get very tired of both me and Uncle Bobs opinions (although they all heard him speak at Öredev) and tell me to put a sock into my mouth... What a dreadful scenario!!! So naturally, I was forced to get an idea. And thus it came to me one beautiful day:

The idea: So why not try to make everyone read the book and we will have a discussion for each chapter? I have previously been participating in a group doing exactly this at Dotway with the GOF Design Pattern book. To me Clean Code seems like a perfect topic and we could probably gain a lot as a company and individuals if we spend some time doing this together.

The idea – the HOW

Said and done. I talked to my colleagues and every developer on the company has now joined. Everyone has got an own copy of the book (it’s actually very inexpensive) and we get an hour once a week on company time to do discussions. Reading is done on spare time, but hey: it is fun reading! Besides, each chapter is quite small and would take little time to read.

So this Thursday, we’ll have our first Clean Code discussion meeting. As a preparation, the meeting attendees will have to read Chapter 1 of the Clean Code book. I have also given them the following questions to reflect upon:

Before reading, take a moment to reflect what the concept of Clean Code means to you.
- Is there anyone of the different "guru's" description of Clean Code (p7-12 + forword) that do you think lies closest to your own definition of Clean Code?
- After having read the chapter, has the reading changed your conception?
What is your experience / opinion of code generation tools or any other higher abstraction level of programming (4GL)?
- Do you have any good or bad experience of building your own code generator (in some way)?
- Where do you think we are heading when it comes to abstraction levels in languages and tools?
- Do you consider this to be a bright future for us developers?
- extra: What do you think of Joel Spolskys described " Law of Leaky Abstractions "?
Have you experienced something like "the Grand Redesign in the Sky" and how did that end?
What is / has been your explanation to having written bad code (as we all have done!) in the past?
Do you think it is suitable for us as a team to align to a "School Of Thoughts" (p12) or do you see any better path to having a more uniform clean code conception?
What do you think of "the Boy Scout Rule" (p.14) applied to code?
Are you familiar with any or all following Principles of Design (S.O.L.I.D.) (p15):
- SRP - The Single Responsibility Principle
- OCP - The Open / Closed Principle
- LSP - The Liskov Substitution Principle
- ISP - The Interface Segration Principle
- DIP - The Dependency-Inversion Principle
What do you think is the status of Clean Code at our company?

I think these questions will be more than enough to discuss for our meeting so we will probably end up choosing the most interesting ones to discuss. I am truly looking forward to it.

Btw, I'll be continuously posting my questions for each chapter on this blog. So stay tuned if you are interested.

The truth vs. the truth

2009-01-17T15:44:25.03+01:00

Some 20-25 years ago as a teenager in School, a teacher once told me and the rest of the class the following metaphor.

Two persons look at a roof top and distinguish a bird sitting at top of the roof. The distance is far so it is difficult to see the details, but one of the persons suddenly says: "what a beautiful peacock!" The other one looks at him bemused and says "that's not a peacock. It's a rooster!" Then the two persons burst into an argument on this matter which lasts for quite some time.

What my teacher then told us is something important I think: Sometimes the truth is different for different people, but each version is still a truth. It is important to remember, and respect, that there may be different versions of the truth which are correct in their own way.

I have come to reflect upon the essence of this very often over the years and I feel I would like to write some fine grained aspects of it:

The truth is context dependent and it is not always absolute.

Both persons actually believe themself to be right, and in a fundamental way, they are therefore both correct. In order to understand this perspective it is vital to consider the context. The context in this example is quite complex since you must take into account things like eye sight capability and what the actual conception of what a rooster and a peacock are. Nevertheless, the person with poorer eye sight or perhaps lesser bird knowledge, still perceive his belief according to his own context. That makes it a truth. Valid in a specific context.

Most likely, you are thinking the same thing as I have been thinking for so many years: There is always an actual correct truth to be found. Take mathematics which should be as a good example. There is always a correct answer to a calculation, right? I mean, 1+1 will always be equal 2, don't you think? However: If the context is Boolean logical mathematics, 1+1 is actually equal to … 1. So whatever truth you think you have, someone may pull a rabbit from a habit bringing a completely different context into the picture which will make your established truth completely wrong.

If the two persons go closer to the building they probably will discover that another truth exists. This is actually where the story continues:

The two men found they could not reach an agreement so they decided to walk closer to get a better look. Soon they realized that it was not actually a real bird, but a statue of a bird. More than that, once they got to see the details neither of them could really tell what kind of bird it was the artist had meant to depict.

Ah! Now we are getting closer to reality I think. Certainly there are better truths that can be found when digging deeper. But very often we find ourselves in a situation where we have to accept a good enough truth. A truth that works for the applicable context. This is a practical truth.

Let us turn our attention in another direction for a while.

Always choose the most important topic in a discussion.

Have you ever found yourself having several discussions going at the same time with someone? Well, unfortunately it occasionally happens to me. Before having reached a consensus from an initial disagreement of opinions, the next disagreement comes up. To make things even worse, the knot to untie the first disagreement depends upon the second disagreement to be settled first. This can continue in an evil spiral of disagreements until you find yourself arguing over 5-6 very different things at the same time. I always hate when I find myself in these discussions since there are too many variables to categorise and sort out. I beilieve that this is one of the obstacles that make discussions such a difficult art. When this happens, there is ususally a call for a time-out in the discussion I think.

But let us turn our focus back to the two persons again. The first person said that it was a beautiful peacock. A bit speculative perhaps, but his main point was probably that it was beautiful, not necessarily that it was a peacock. This would be the main sensation he had and most likely the feeling he wanted to communicate. But by doing so he found himself ending up in a discussion that probably had nothing to do with his original sensation. If the two persons enjoyed the bird discussion and considered it as meaningful, perhaps it was a fruiteful one. However, I think they hit a a side-track and discussed a less prioritised issue. If this is so I think both persons could have given in earlier by saying something like “oh, perhaps you are right”. Then they could have focused on the original and probably more important message: beautiful or not…

Although the story is a vague example on this, I think we often do tend to discuss less meaningful things just because of curiousity or a sheer willingness to be right. Instead, we should focus on the stuff that matters within the important context!

I’ve met some people who loves throwing arguments in a heated discussion and who might even provoke a person in order to get it. I’ve also come across some people who have even lied about their true opinions in a discussion since they wanted to test the opponents’ arguments. This discussion tactic may be a dangerous road to walk. In the end the person often end up confessing that he had not really been arguing with his true mind. If these types of discussions keep reoccuring with the same person, unfortunately my trust fades away. Do you want to spend your time discussing something with someone in whom you have no trust?

So let us get back to a final aspect of truths in a discussion.

Considering someone elses truth is about showing respect and having patience.

With this aspect in mind it becomes a whole lot easier to actually listen to people in a discussion/argument. Quite clearly, the more confident of an opinion we become, the more difficult it is to be open and appreciate different ways or slightly different truths.

I think that listening and appreciating other peoples truths is the most important ingredient in a discussion. You will never truly "win" a discussion if you don't pay the other person respect by giving him proper feedback showing him that you are actually listening and understanding his truth. And by saying paying respect, I dont mean shoveling a line like "yes, perhaps you are right, but..." and then quickly head on to your main point. That's nothing!

I would dare to say that showing that you listen to someone is a very physical thing. People who are good at this highlight this attention using their whole body. We normal mortals mostly have to stick to the use of our eyes. Your interest and intention should very clearly be shown when you meet the other persons eyes. A bit of a magic trick to that wordless communication phenomena, but eye contact communication does actually work in this sense. That is how you are showing your interest in his version of his truth. Not by opening your mouth quickly and say something stupid like "yes, but"...

I also think it is best if this effort is sincere and not just a plan to get your own point across. Be open to that you both have a version of the truth (or even that you can be wrong) and you will both probably gain a better understanding of a deeper truth in the end.

I firmly believe this is the key to successful communication and I am constantly trying to become better at it myself. It is not easy in the heat of the moment in a discussion. And I must admit I sometimes fail due to lack of patience... But, hey, the road to perfection is a long and fun one to walk! :)

Recap from Øredev 2008

2008-11-25T19:20:47.796+01:00

Last week, I visited the Øredev conference. I had a gread time and since this is the forth time I attend the conference, I can see how much it has grown from the first year in 2005. Back at this first conference in 2005 I presented myself together with Magnus on the topic of AJAX which was a bit of a hype at the time. I don't know why I did not even blog about this then but sometimes I am a lazy blog writer... :( Anyways, seeing all these great speaker it does trigger an enthusiasm to get back into the game. We'll see, maybe next year I'll make a shot at present something at some conference. Certainly Øredev would be my first choice. If they would let me in again... :)

This year the conference was for a whole week. Two days with workshops and courses and three days with regular conference sessions. I visited the 3 days only this time. Although I probably did not manage to always pick the topic that suited me the best from those available, I think I still got a little something out of everything.

The topic of the conference was "Share Knowledge" and I think this is certainly true and a well chosen phrase. But most of all, for me, it is about getting the inspiration to dig into new fields of interest. Most, if not all speakers are very dedicated about their own topics of interest and I believe all of them spend a share amount of their own spare time to become as knowledgeable as they are within theses areas. This is the essence of passion I think. That you volunteer to walk the extra mile in order to stay on top of things and in control. Naturally this brings with a certain amount of enthusiasm in the air that is easy to grasp and feel. So, to me, the importance of this visit boils down to this important sentence:

It becomes easier to remember that it is fun and rewarding to stay passionate about your work after a visit to Øredev.

This is a simple statement but in essence it often means that you will pick up a work related book after work or sit down in front of the computer once again after an already finished 8 hour session during the regular work day. An easy thing to say, but less simple to achieve. But if you are passionate about something it definitly becomes a lot easier. Essentially:

Passion is what drives us to become better at what we do.

Another nice thing about Øredev is that it there are many cross-discipline tracks. So it is easy to slip into the Java track, or the Testing track for instance when you feel the curiousity of a topic. There were 12 different tracks to choose from this year so I think it was quite easy to find something interesting somewhere. Naturally, there were sessions that collided making me bring out the dice, but video recordings of sessions are coming up I hear. So this parapgrah basically brings on the next important punch liner:

Øredev makes it possible to think a bit more outside the box you tend to place yourself in after weeks and weeks of regular work.

I find it a bit hard to retell which sessions I attended and what I thought about them. Basically since it would be a book writing that I never would finish. But I do say that the absolute highlight for me this conference was to see and hear Robert C. Martin speak. His book Agile Software Development, Principles, Patterns and Practices has meant a lot to me as a software developer. It has completely revised the way I think about code and the importance of making a good design. There were a lot of quite famous people on the conference so I'll just skip the remaining name dropping here and instead urge you to view the excellent program selector (as already linked to above).

Oh, one more thing definitely worth mentioning: Øredev did support this year builing schools in Africa via UNICEF which I think was an honorable thing to do. I bought a brick at the conference and I encourage you to do the same. It is probably never too late to be a hero. :)

Last but not least:
Mucho thanks to the Øredev team that pulled this togheter once again this year! Looking forward to next years conference already!

A very unpleasant awakening...

2008-11-18T07:58:41.403+01:00

This morning I woke up to a real nightmare. Yesterday I had set the alarm on my mobile phone to wake me up at 6.30 in the morning as usual. I knew when doing this that I probably would suffer a bit waking up since I went to bed way too late. But what the heck, it is only sleep, my last train of thought went before going to sleep. Oh, did I pay for this a couple of hours later!

Since my girlfriend wasn't getting up as early as me I had been particularly careful to set the alarm to use an increasing volume. Also I turned off the phone battery vibrator since this tends to make the whole room vibrate when the alarm rings, which even wakes up our cat Disa who usually sleeps at my feet.

Before I go on and tell you about my nightmarish wake up, I'll tell you about a previous experience with another brand from this particular mobile phone manufacturer. That mobile phone screamed out with a terrible melody whenever the battery was getting low. In most cases, this is probably a good thing since you really want to make sure this never happens. But with this particular mobile phone, it was not configurable to turn this feature off. So naturally, the alarm woke us up in the middle of the night on a number of occasions.

Eventually I managed to learn that phones' user pattern to take the battery out before going to sleep. Or even better, plug in the electric charger... Anyways, I think most people would value sleep over the mobile phone not running out of battery.

So, back to my devilish wake-up this morning. At 6.30 this morning the mobile phone alarm started ringing at a low volume as should be. Unfortunately the alarm went off during the wrong time of my sleep cycle so I was really dead tired with most of my brain neurons still sound asleep. I also woke up finding that my left arm was missing. I could not find it anywhere.

As the sound of the alarm screamed louder and louder, I slowly realised that my arm was gone because I could not move it. It was completely lame. I did not feel it anymore.

This can happen if you sleep with the arm in a weird position for a long time. It will wake up again and becoming fully functional after a couple of minutes of free dangling time. So I actually did not panic. Yet.

So that leaves me with one arm and a tenth of my normal brain power to turn off the phone. Piece of cake you would think?

A regular alarm clock usually has one big “turn-off-alarm button” that is easy to find. This morning I realized that there is a reason for this. In my delirious dreamy state, I started pushing all the buttons all at once on the phone with my functional hand. But nothing happened. Instead the alarm started to ring louder and louder. With a steady arising panic I begun to realize that the alarm would never ever again be turned off. I would have to live the rest of my days with this noise ringing louder and louder in my ears.

So I fumbled on in my quest to turn the damn thing off rushing out of the room, stumbling over poor Disa who for a second managed to scream louder than the phone. Perhaps if I poured water on top? (on phone, not cat!) The electronics probably doesn't like this so that would probably work.

Fortunately, my brain power was slowly booting up again so I never fulfilled my idea. Instead my one hand remembered the old trick and after lots of struggling (one hand!), I managed to pull the plug out of the sound by removing the battery.

Phew! Silence! Finally!

But the screaming alarm was still reverberating in my head with anguishing anxiety. And I knew that my girlfriend was probably lying in her bed cursing me and only me for this! Well I curse the phone in turn!

Ok, so having woken up a bit and sitting here at breakfast with my beloved cop of coffee, again being able to hold it with two hands, I think I realized what went so terribly wrong this morning. Firstly, I now grasp that I sometimes never will learn how to turn the alarm off the ordinary way. Especially not so with one tenth of my brain power and one arm at my disposal. Secondly, for some reason the phone key lock is sometimes not lifted when the alarm goes off. This is clearly a software bug since normally, one only has to puch any button to turn the alarm off. Devastating bug I would say... And if it is not a bug and if there is a logical explanation to it, well even worse. If I find this to be the case, I might even reveal what brand of mobile phone it is in this blog post.

Some thoughts on the future of mobile phones

Mobile phone companies have started to talk a lot lately about turning the mobile phone into a generic all-in-one toolkit; kind of like a Swiss army knife. Keys, credit cards, you name it. I would love for this to happen. But I also would love the phone software developers to think in turns of how these devices are actually used in each scenario. Why is there a big button on the alarm clock and how can this be simulated better and always work on a mobile phone?

These type of questions, I think is always extra important to ask for product manufacturers. And particularly so when they are to support a new functionality that it originally was not designed to support. As in simulating an alarm clock when you are in fact a mobile phone.

Naturally, looking back at this morning I laugh about my desperate attempts to turn the alarm off. But I also think that I never will buy a mobile phone from this particular manufactorer again. But then again. Perhaps I will. I am usually less cranky after I have finished my morning cop of coffee.

The Running Mate - The geometry calculations

2008-11-02T14:54:50.477+01:00

This blog post is part of a series that start here.

I have already descrived what the Running Mate is and why I would like to build such a thing. Now, it’s time to get my hands a bit dirty with the mathematical theory that’s needed for this. I would not say that it is an advanced mathematics, but it is definitly a fun applicability since it is really easy to see and understand the purpose and need for the mathematic formulas.

So here’s my 10 km run again. Let us focus on small area of this run: the square that the red arrow points at:

If we enlarge this square area, it would look something like this:

As you can see, I’ve painted some blue stars on the map and high-lighted the road with a black line. The blue stars signify the GPS points that my running mate is picking up with the help of the satellite(s). I don’t know how often these coordinates actually come, but naturally, I will not be able to get the exact track of my run. By drawing a line between the coordinates we will se how the running path looks like according to the PGS system. Here is another image high lighting the coordinates with their straight lines between them in an X-Y graph instead:

Calculating the distance between these stars in this graph is simply a matter of utilizing the Pythagorean Theorem. I honestly think that no matter how rusty your math knowledge becomes, this formula will forever stick in your head:

z² = x²+y²,

z is evidently being the sought distance between two of the stars in my graph. So in order to withdraw the distance between the second and the third coordinate, the formula becomes:

z² = (x₃-x₂)²+(y₃-y₂)²

Calculating all distances between all coordinates on the map gives us the total distance which is exactly what shapelink.com did for me when I utilised their service to draw my run on a map. Basically, I gave them the coordinates by clicking on the map and they drew the lines in between these coordinates and calculated the total distance of the run.

But we are still not at where I want to be: getting the current time comparison of each spot to a previous run. And this is where the fun begins.

The difficult part here would be to compare different coordinates from different races with each other. Naturally, the coordinates will not be on the exact same place as the previous coordinate. This image will illustrate this:

Here I have high-lighted a second race coordinate with red stars. As you can see I did not run the exact same spots as I did the last time I ran the race. The deviation shown is most likely larger than what would be in reality considering that the track I run on is quite narrow. But nevertheless, I obviously have to take this into account when comparing the coordinates.

Naturally each coordinate also has an associated timestamp. As I see it, finding the coordinates that are closest to each other in order to calculate the difference between the two timestamps can be done in at least two different ways. Let us start with the easiest one.

Algorithm: Finding the closest coordinate

So, as this image shows, we have to calculate the distance (d1, d2, and d3) for each red coordinate to all blue coordinate and pick the one that is the closest to the red coordinate. The needed calculation is basically just a matter of using the Pythagorean Theorem again a number of times, so it is a piece of cake really.

In the example in this image, the d3 distance is obviosly the shortest one so this coorrelating blue coordinate is selected as the one to compare against the red coordinate. The difference in timestamp between these two coordinates would give you the desired result for the Running Mate application. If we don't need a more accuracy result, this is where we would stop.

However, of course we want more accuracy, so let us move on to the more interesting algorithm.

Algorithm: Interpolating the time

As you might have gathered, the previous algorithm is not particularly accurate when the number of coordinates is low for a run. If the number of coordinates approaches infinity (as mathematicians do love to state) the result would indeed be good. But if merely a few coordinates would have been used for the whole track, naturally this first algorithm just doesn’t cut it. This is when time interpolation is needed.

In this image we are focusing on two of the blue coordinates, B₁ and B₂, that lies closest to one of the red coordinate, R₁. Basically, we want to find the V (as in Virtual) coordinate in order to find the time interpolation between the B₁ and B₂ coordinate. All we have to do is to calculate the ratio of the distances between the coordinate V and the B₁ and B₂ coordinates. This ratio will give us the needed number in order to calculate a new blue time stamp at which the virtual V coordinate is located.

So in theory, this algorithm seem to boil down to the following steps:

Find the two blue stars that are closest to the red star.
Find the coordinates of the virtual coordinate V.
Calculate the ratio of the distances between coordinate V and the two closest blue coordinate.
Calculate the virtual timestamp of coordinate V using the ratio found in step 3.
Compare the timestamp for the red coordinate with the new virtual timestamp for the coordinate V.

The only difficulty here really lies in the second step of this algorithm, i.e. finding coordinate V. So let us concentrate on the information we do know, i.e. the known variables. Consider the following image:

Here, d₁ is the distance between B₁ and R₁, d₂ similarly between R₁ and B₂, and finally d₃ being the distance between B₁ and B₂. Ok, these distances are not known, but we do know that if we have the coordinates, we can easily calculate the distances using … yes you guessed it: the Pythagorean Theorem. So we can consider these distances as known.

Ok, next would be to calculate the angle α at the B₁ coordinate. Knowing all distances d₁, d₂, and d₃ in this triangle we can utilize the Law of cosines:

d₂² = d₁² + d₃² - 2d₁d₃cos(α)

The only unknown variable here is the α angle which a bit of algebra magic solves for us.

So when we have α, we can calculate the distance d_v, i.e. the distance between B₁ and V coordinates with the following basic trigonometry formula:

Cos(α) = d_v / d₁.

Again, a bit of algebra gives us d_v and you know what? We are actually home safe now with this knowledge. Basically we now know the ratio in distance V between B₁ and B₂. Now all we have to do is to apply that ratio to the timestamp of B₁ to get V coordinates virtual timestamp.

I have not yet had the time to implement the second “interpolating the time” algorithm in my Running Mate code demo as available at Codeplex, but when I have I will delete this sentence and add a comment about it.

The Running Mate - Code available at Codeplex

2008-10-31T17:37:03.122+01:00

This blog post is part of a series of blog post that starts here.

Well, to be honest, it has been available all since this Monday before the Swenugpresentation. But I just added some missing files too so now it actually compiles too... Sorry about this if someone chose to download the code right after the presentation.

As perviously stated in this blog post series, I initiated the creation of the Running Mate mostly because I needed a demo application for a performance talk. It served its purpose well I think, and I think I can make use of this applications in upcoming presentations. However, being a demo application, it is far from complete in functionality:

There is no PDA based version of this code built yet. I.e. the device that tracks and sends the GPS ticks as you run to the server. Obviously without this, there is no purpose of the Running Mate. So I hope that I or someone else will have the time to build this eventually.
There is no real Graphical User Interface built yet. I built a test load client for simulating the load and I also built a windows client application for inserting the test data into the database which both are available. But the real GUI is not built yet. I have some ideas for this and hopefully someone will help out with this GUI eventually since GUI is not my cop of tea...

As for all the source code it is available here: http://www.codeplex.com/runningmate. It is published under the GNU GPL v2 license model. You can quite easily use Subversion (TuroiseSvn client) URL at https://runningmate.svn.codeplex.com/svn or the TFS Server URL at https://tfs05.codeplex.com.

I am usnig SVN myself and unfortunately, the throughput is very low. I suspect Microsoft is actually to blame here since Codeplex is a very popular open source repository these days. Microsoft don't seem to have scaled codeplex to meet the demand. If it does not improve or if I see it is a problem I might move to another availble code repository. We'll see.

The current file folder structure in the repository looke like this:

Although this most likely will change in the future, the idea is that a working, non-demo version of the code will be available in parallell with the DemoVersion folder. Eventually..

In the VisualStudio folder, all the C# 3.0 code is placed. I am using Visual Studio.NET 2008. Currently, I am running MySql as the data persistance provider, but I might make more options available too. After all, MySql requires a MySql server to be installed in some way or another (there are quick ways to install it) so it is a bit too much of a hassle to get the application up and running if you are not using MySql. The DB folder has everything you need here though for the application script wise, but please let me know if something is missing.

Hmm, that's it for know I think. I'll back on the topic of design and architecture in an upcoming blog post.

Performance Talk at Swenug in Göteborg

2008-10-26T23:24:03.997+01:00

Ok, so this is my third blog post today. Gotta be a record for me I think. :)

On Tuesday I will be presenting on the topic of performance optimization at Swenug in Göteborg. This last year I have been working quite a lot with this focus at Admeta. The topic of this talk is: 1 billion web request - response time 50 milliseconds. This is actually not a lie since we have these types of requirements at Admeta. One billion request is quite a high number so I do understand if there is a mild hesitation if it really can be true. But asynchronous requests from multiple high load pressure web sites can stimulate this type of requirements, trust me.

I believe the presentation will be approximately 2 hours, but there will be room for some discussions. I've been at a number of Swenug presentations by now here in Göteborg and I think the atmosphere is very relaxed and nice. I hope for the same nice athmosphere on Tuesday with lots of interesting questions and discussions. So this is what I planed and prepared for my presentation:

1. Load testing process and demonstration

Load testing is of vital importance in order to understand how the load pressure will affect your web site. Scaling with more machines is not always something that you can do hastily if the need arises and it sure does cost a lot of money to do it. So it's good to know a little of what you application could behave in production before you launch it. In this part I will go through the load testing procedure, what to look out for, what data to collect, and give various other hints based upon my experience in the area.

2. Performance Profiling with the Running Mate application

For profiling och optimising, I will demo with a new hobby application that I just recently built: The Running Mate. The special thing about this application is that I have built the domain very loosely coupled with regards to the application layer making it possible to switch the domain layer at runtime. I am basically providing these different types of implementations:

a) The Super Hack: this was the running mate application as easy as I could possibly implement it. Not much design work. But fast?

b) The Overkill Design: This application is a bit overkill since the domain model is interchangeable in runtime. I would say that in most cases, this is not how you would normally decouple the domain layer since the need for it often just isn't there. However, it is very useful if you would like to profile performance with regards to different types of domain model implementations. The architecture pattern is that one of the Domain Driven Design (as described by Eric Evans) which gives the system a very nice Separation of Concern I think. One of the provided domain models is using a traditional Data Access Layer implemented in DDD repositories. The other provided domain model is using the Mindscape LightSpeed O/R mapper which we have used at Admeta for quite some time. As you can see in the link it is providing a bunch of nice features and it is very nicely DDD oriented.

So, I think there is enough substance here for a two hour session with discussion. All code demonstrated during the evening will be provided at CodePlex at http://www.codeplex.com/runningmate very soon.

The Running Mate – What is it and why?

2008-10-26T22:39:54.315+01:00

This blog post is part of a series that starts here.

I have long distance running as a small interest of mine. It is far from a passion, but I try to get out in the forest and run a distance of approximately 10 km every weekend. I usually run in a park called Hisingsparken here in Göteborg which is a beautiful and peaceful forest to run in. With the courtesy of shapelink.com , here is a map of the 10 km lap that I usually run.

Well, beautiful and peaceful isn’t all, is it? The current condition and health situation surely makes running a lot more enjoyable. And in order to get in fit which makes running a great sensation, you have to run faster and push yourself a bit. So this blog post is basically about finding this motivation with something called the Running Mate.

In order to motivate myself to run a bit faster, I clock the time it takes to run the distance. But unfortunately I seem to be stuck at about 55 minutes for 10 km run which is a bit too long time I think... I know. There are various good ways to improve the time: run more often, vary with shorter distances etc. If lowering the time would have been of really strong importance to me, these ways of doing would probably suffice for me. But as it, my level of interest makes me look in the direction of technical tools to help me out…

My problem when I run is probably motivation and focus at the running process itself. I let my mind wonder and I think of everything except keeping the correct pace. Running is great for problem solving by the way. Anyway, the clock does not give me this feedback since I have no idea of what time I am supposed to have when I am looking at the clock during the run. Naturally, this can be solved by having a number of part times at specific distances. And I do, but I don’t really want to keep track of too many of these part times since it disturbs my thoughts on other things. I would like to be able to know instantly, at the time of interest, what my pace is compared with a previous run at that exact spot of the run.

So the answer is obvious: The running mate application. It has been possible for quite some time now to buy a GPS equipped watch with this type of applications. The main idea is that it should be possible to run against yourself, i.e. being able to compare your current running time against a previous time you have had in a previous run at each and every spot of the run.

So I could have gone ahead and bought this GPS device. But something has stopped me so far. Of course it would be cool and exciting to fabricate this tool myself with the help of a mobile phone and a GPS device. Not that I know if I will ever get around constructing the whole thing, but I intend to build something in code and blog about it. I do this partly because it is a fun thing to do, but also since I think this application could be the basis for future examples both on the blog as for presentation I do.

So next blog post, coming up soon I hope, will be about the mathematical geometry needed complete such an application. Fun stuff I think.

The Running Mate - An Introduction

2008-10-26T22:12:12.251+01:00

For quite some time now, I’ve been thinking of the design of a so-called Running Mate application. I decided that it was time to implement it and the trigger that set me of was to have a fun example to use at a performance tuning presentation. So beneath is what I have in mind as blog topics although it can change somewhat as I go ahead:

The Running Mate – What is it and why?
This is a personal touched blog post with the background story as to why on earth I think the Running Mate application is a nice thing. Off course, this blog post also lets you know what the application is actually doing
The Running Mate – Code available at Codeplex
Source code available and some words about what is provided and what is not provided in the repository as well as some file structure information.
The Running Mate – The geometry calculations
In order to implement this application some interesting geometric calculation is needed. This blog describes these calculations.
The Running Mate – The Super Hack implementation
Sometimes I start off by doing a rather quick and dirty implementation of the application and then refactor my way into a more nice design. I didn't actually do this for this one, but I needed super hack implememntation for my presentation. So this is breif presentation of a quick and dirty implementation.
The Running Mate – The Domain Driven Design approach
In this blog post I transform the application into a design that is closer to a Domain Driven Design.
The Running Mate – The O/R Mapper Repository
The repositories built in the previous blog post uses a classical database access layer wrapped in repositories with inline (ad hoc) SQL. Here’s an alternative approach with the MindScape LightSpeed O/R mapper.
The Running Mate – The loosely coupled Domain Layer
Most O/R mappers integrate into the Domain Model rather tightly and make it a bit more difficult to switch from one O/R mapper to another one. This is a bit strange since O/R mappers themselves make the choice of underlying database very flexible. In this blog post I describe how you can decouple a domain model from the application so that you can have several different versions of domain layers that the application can utilize. The loosely coupled domain model is not always that useful in reality, but it is a nice experiment.

I may change the topic names slightly as I go ahead and write about them, but I hope you can live with this. There are actually many more blog posts that I can write based on this application. For instance I would like to write some more about the LightSpeed O/R mapper and how you can wrap the basic CRUD stuff to make these methods really easy to access with a simple API. Also, there is a lot of stuff on performance tuning this application that I would like to write about eventually. But I better not promise too many blog topics in advance since you never know what lies round the corner.

So. Basically, I am back in the blogosphere for another round.

File based vs. wiki based documentation. part 2

2008-02-03T23:15:27.624+01:00

In a previous blog post, I covered the following topics:

· Published, not stored which basically allows for more people to read the document.

· Refactoring structure allowing for documentation to stay agile and up to date with a current content and structure.

· No special roles, instead accountability for taken actions!

· WYSIWYG vs. wiki syntax basically stressing that simple editing markup is good enough for most types of documentation.

In this post I will instead dig into the following two topics:

· Local feedback which allows for history of decisions to be associated to the source of the information.

· High cohesion and low coupling is a well known programming principle. I think this principle can be applied to documentation as well which is better supported with wikis than in file based documents.

We sure do communicate with each other a lot at our job. This is mostly done in a synchronous way with verbal communication. Most often agile methodologies favor verbal communication over written communication since it is considered as the most effective way.

However, there are other ways of communication which are of an asynchronous nature. Such communication allows us to write information or questions to other people and do other things while waiting for the response to come back.

Asynchronous communication also allows for us to take the time to formulate a good text that correctly describes the important part of the message. Sometimes this is a great strength over verbal communication since in an intense moment we do tend to talk past each other, not understanding what the other person is trying to say. Of course it can also be a weakness since we don't get an immediate feedback of what we are stating. But this is a completely different blog topic which I probably will write eventually.

However, an example of such asynchronous communication is of course mail, which probably still is our most commonly used communication tool at companies. Yet another example is some kind of chat messenger like MSN Messenger or ICQ which also is of an asynchronous nature. In fact you can find yourself having a multithreaded dialog with someone on a chat application with several topics being discussed at the same time. At least, I know that we programmers often do this. Very effective indeed! :)

So what about wikis? Let’s look into this now:

Local Feedback

I would say that we often use mail to communicate with each other at work since the asynchronous nature is convenient. However, one disadvantage is that important information as to why we reached a certain decision is persisted in our mail box only. Unless you are extremely organized with a myriad of mail folders, it will become difficult for you to find this mail conversation later on.

I find that even searching for mails, as gmail states as a big strength of functionality, many times this does not work because I can’t remember the exact words to use in the search... In this case I am left with my structured mail folder hierarchy in order to find the message. After a couple of years there may be thousands of emails in each folder… But then again, perhaps this is only a problem that I have… :)

Another issue is that information is not published for others to read apart from those in the recipient list. At least for some topics, the information has to be brought out and written somewhere else where more people can read about it. I think that some ”non-secret” topics instead could be published and discussed directly on a wiki omitting the mail dialog. Many wikis offers comments or some kind of discussion board to be associated with the wiki page that can be used for this.

One wiki that successfully uses this approach is Wikipedia. Since everyone is allowed to enter information in Wikipedia, naturally, conflicts of opinion occur frequently. Take a look at this page for instance and please notice that it is the discussion tab. The page contains the discussion of what Inversion of Control is and how it could be explained etc. Unfortunately the meaning of the term is very different from programmer to programmer as you can see. But with discussion, eventually a mature and natural consensus can be reached as to the meaning of the term (ubiquitous language established, see this blog post). Unfortunately not yet so for IoC.

However, the essence here is that the information as of how the meaning of a term was concluded is stored locally and connected to the information itself. I.e. effective metadata! I think this is a great strength.

Naturally, there is always a decision to be made what discussions are to be held in public on a wiki and what discussions are to be held in mailing lists. I am not arguing for abandoning mail here! :)

High Cohesion and Low Coupling

I would dare to say that all programmers have heard this statement (and if they haven’t, it would be time to do a little bit of studying. :)) However easily stated it is not as easily achieved. I also dare to say that it takes years of programming before getting skilled enough to realize the importance of the statement as well as knowing how to apply it well.

I have often reflected upon lately that successful communication should apply to the same principle. When explaining something to someone, we have to stay focus on the topic. Otherwise, we confuse the audience with too much information (information overload). Sometimes we need to explain a side track in the discussion before we get to our main point. Recognize this scenario? Well, it certainly is the difficult art of pedagogic and it is the importance of having common reference knowledge.

Perhaps being a little bit daring, I think the interpretation as to the meaning of high cohesion and low coupling is quite similar when it comes to communication. Looking at a story to be communicated to someone else, the main focus lies in the main message you want to get across. This information could be compact, i.e. high cohesiveness, which will make it easier to understand. But it often relies on other information, I.e. it is coupled to the other information. Naturally you would like high cohesion and low coupling to get the main point across quickly. But this coupled information is often what makes the story complete in its context and it gives the story its nuanced and interesting flavors; although making it more difficult to understand.

Having established this interesting parallelism, let us turn an eye in the wiki direction. I have already established in the part 1 wiki blog post that refactoring of the wiki structure is an easy thing to do. This is important since it allows for us to provide pages that have a high cohesion. High cohesion in wikis is pretty straight-forward to achieve since the page refactoring support is there.

However, the thing to look out for is strong coupling. Although a good wiki should be able to update linking between pages when you change them, you may run into many fragmented pages with too many links (high coupling) to other pages. This is where your sense of structure and judgment comes into the game. I dare to say that there is no tool that can do this structuring automatically for you since no tool can predict exactly what you will write.

This is nothing new really and I believe that every good communicator has come to realize this and applies to this principle whether it is in writing documentation or merely speaking to people.

In my next, and perhaps final blog post about wikis, I will have a more practical approach as to how to choose which wiki to use (there are lots of them out there). I can’t say I am an expert of all those wikis, but at least I’ve learned some aspects to look for. So until then, stay tuned.

PS. I probably should admit that my interest in blogging on other topics recently has gained which I might prioritize writing (as well as time spent not blogging… :( ). So if you are interested in number 3 in this series, please let me know and I’ll try to speed up the persistence of that story.

File based vs. wiki based documentation. part 1

2007-12-11T00:26:31.286+01:00

I started out this web 2 series with a rather general introduction here. However I have to admit that I wasn’t very specific, nor pragmatic in this blog. This has got to change right here because for me web 2, and especially wikis, is all about a pragmatic approach:

The ability to document necessary and important information and allowing for as many people as possible to read, edit and give feedback upon this information.

This is collaboration. This is wikis.

Unfortunately, documentation often has a poor sound to it these days with the agile winds blowing in the software industry. Don’t get me wrong, these agile winds are definitely good and I think we are on the correct path here. However, I think there still is a need for some documentation. Only, the documentation has to be as agile as the process of developing the code itself. This is where wikis come into the picture as a better documentation persistence tool.

The traditional documentation approach is by using a file-based storage for content. Usually the tool is some version of Microsoft Word which is probably what 90% of what people are using. The editing functionality in this tool is excellent. However, I do recognize a number of weakness as I will note down as I go along comparing file based storage with wikis.

Published, not stored!

A wiki is always reached via a web browser. Therefore, when writing content on a wiki, it is naturally published on a web server for all authorized users to see. This is a great strength since everyone these days are used to a web browser for localizing information.

File based documentation is however often a pain to even locate on a company. Often, such files are placed on a file server somewhere in some obscure directory. Often I find that there are several of these directories too which makes the wanted document even more difficult to find.

However, an interesting approach is Microsoft Collaboration platform SharePoint. Here SharePoint is responsible alone for knowing the actual physical storage of the file and files are only provided as links to the users for download or viewing. This is a lot better approach. Unfortunately, due to licensing costs, a SharePoint solution is often not doable for smaller companies.

Refactoring structure

As when programming code it is difficult to know the exact structure before work has begun. Requirements (input data) may change or you may get new ideas as you work with the code/document. When creating a file based document, the scope for it has to be carefully considered. The information that is out of scope has to be placed in another document which instead is referred to. I find that file based documentation does not leave you much choice for actually editing the scope of the document once you have started working on it. Wikis on the other hand allow you to quite easily refactor the structure and scope as you go along. This since the actual document you are writing is split into several pages reachable via links. It is quite easy to create a new page in a wiki and link to this page which makes refactoring extremly easy. Referencing other file documents in a file document is a much harder this to do. At best you may link to a referenced file document, but this document still probably is a huge source of information so it will still take you quite some time to locate the desired information within this referrenced document.

This refactoring mechanism is one of the largest benefits with a wiki I think. It allows us to split huge sources of information in one document into several documents that are easily linked to from other pages. There is a striking similarity here to the software design Single Responsibility Principle. A class as well as a document should only have one reason to change…

No special roles, instead accountability!

Usually, a wiki does not divide people into authorized and unauthorized groups of people. Naturally, only the group with interest in the wiki may gain access to it. But aside from this authority level, everyone in the group may write whatever on the wiki pages. Usually, this would go for the whole company as long as there are no specific security reasons to conform to.

However, although anyone can edit any page, a wiki should always provide an easy way to see what was edited and by whom. This means that accountability is there since it is always possible to see and compare the different versions of a wiki page. Also, wikis should provide an easy way to roll back to a previous version of a page.

Having security restrictions often lead to more maintenance and trouble than what it is worth. If there is no top secrets on the page, let people view and edit the information as they want. If a change was bad, well contact the person for a verbal discussion and hopefully roll back the page afterwards after you have agreed upon what should be there.

As far as I know Microsoft Word does not provide any version tracking possibility on file level so this is often added manually in the file instead. However, the SharePoint platform does give you a versioning and roll back possibility for word files. However, I don’t actually know if it is possible to compare different versions of the word file with each other.

WYSIWYG vs. wiki syntax

Microsoft Word offers WYSIWYG editing. I.e. What You See Is What You Get. It means that MS Word hides the small symbols from us that make bold text go bold and underlined etc. I think MS Word does an excellent job at this (although there are still bugs) and the application has definitely reached a mature status.

I would say most wikis are not mature when it comes to WYSIWYG editing. They are far from as feature rich as MS Word WYSIWYG and often you find yourself cussing over a behavior or a bug that you are used to in MS Word. I believe WYSIWYG in wikis will probably mature during the next couple of years and that the difference will disappear.

However, the WYSIWYG editor, if even provided, is often not what the wiki user utilizes (at least not if he is a programmer searching for control of the tool…). Instead he goes directly for the wiki syntax which is simple to use. Unfortunately, there is no standard here and the syntax varies between different wikis. Bold letter in some wikis would for instance be rendered by adding a star between the word: eg. *This text would become bold when the page is saved and published.*

And a small summary

Well, I have lots more to write about wikis but this will have to wait for a future blog post. Probably, this is even now to long for a blog post. Hopefully someone is reading this eventually. And if you do: stay tuned for more…

Complementary thoughts about software entropy and broken windows

2007-12-02T11:40:05.994+01:00

Andrew Hunt and David Thomas have a written a great book called The Pragmatic Programmer. This book covers so much great stuff! Most of the time, while was reading it, I found myself sitting with the jaw against my chest in astonishment of how clearly Andrew and David pinpoints problems and recommendations in software development. I think all seasoned developers would have the same feeling since the problems Andrew and David writes about are well-known, but not very easy ones to actually pinpoint and describe.

As a side note, at the Øredev conference recently, I saw Andy Hunt giving an excellent key note speech opening up the conference. There was quite a number of fascinating subjects he talked about and I hope to be blogging on some thoughts on these subjects in the near future.

Anyway, in the book, the writers bring up a term called software entropy as a force very difficult to avoid for developers. When I first heard of entropy it was actually in chemistry class many years ago. An explosion is an excellent example of a chemical reaction that renders a very high order of entropy. I.e. the amount of disorder of atoms in the explosion is very high in the beginning but rapidly goes back to a low level of entropy. Naturally, this is due to the high amount of energy that sets the atoms in motion.

There is a striking similarity with software entropy I think. When things are heating up in a development team and we are as busy little bees to meet a deadline, entropy is bound to be high. Or at least the risk is very high that the entropy gets high. As a cause of this, Murphy’s Law might appear out of nowhere which seems to be a result of just pure bad luck. But often it is the just the result of high entropy, i.e. the disorder tends to get high as we get stressed out and several accidents happens in a short amount of time.

The writers go on with an analogy to city buildings that are of very different quality in different neighborhoods; some buildings being very clean and neat while others in another area are in a very poor state. This is the effect of “a broken window”. If one window gets broken and it does not get fixed immediately, then soon another broken window will appear; and yet another and so on. Soon the neighborhood will look like skid row and criminality increases drastically.

That this is so, even Swedish governments have concluded. I recently saw a news program stating this very fact. And in the local news paper the same very fact got stated about a neighborhood not too far from where I lived. A whole city block is going to be torn down and rebuild and as a result, criminality is sure to drop it was stated. Well, good!

I think there is an absolute truth in this and that it can be explained with our pride. If you are not proud over the neighborhood you live in, you are not going to respect either the buildings or the people that live in them. But if you feel pride over a good, esthetic environment that surrounds you, you take more care of it.

As for software development, we have the same situation Andrew and Thomas states. If you don’t feel proud over the code that is produced in the project and honor its design, the software will begin to rot. If this happens, sooner or later you probably are going to have to throw it all away and redo the whole thing from scratch.

So, as the authors of The Pragmatic Programmer so wise fully states: don’t live with broken windows. Anticipating that the design of the software is a good one, follow it instead of doing small hacks in order to save time. That time you save may very well be 10 times the time lost further down the road when someone is trying to get the once upon a time nice design to work again as it should be.

I know: Software is never perfect and this is not what the authors, neither I, are saying. However there is a great difference between delivering good enough software and doing “hacks” to the system all the time.

Unfortunately there is a driving force that often makes these hacks necessary: the critical deadline of a promise made to somewhere by somebody by someone... But the underlying reason for this is often due to a crappy or not existing project methodology which is a subject that I won’t dig into in this blog post. However, this spring I probably will write a lot more about this.

Ubiquitous language == a common terminology

2007-11-29T08:31:30.416+01:00

The first time I heard the word ubiquitous, a sigh of utter and ignorant reluctance went through my mind. I figured that such a beautiful but complex word is absolutely bound to bear an over-complicated meaning to something that perhaps might be very easy. And unfortunately, that killed my interest at the time. Well, having understood the importance of ubiquitous language my interest is gained.

So what does it actually mean? Well, a quick search at my favorite place to look for strange words gives me a hint. When adding the word define: before a word, acronym, abbreviation whatever in google, a search will be done at a number of open dictionaries on the Internet. This is nice since the explanation of the word is given in a number of different contexts which gives me a broader meaning of the word. With this search, define: ubiquitous, 5 different explanations are rendered. The one I choose to show to you is this one:

omnipresent: being present everywhere at once
from wordnet.princeton.edu/perl/webwn

In Swedish I would translate this to “allomstädes närvarande” which is even more poetic I think. :) However, the English translation put us a bit closer on the map as to an understanding of the word, but we’re not there yet. What is omnipresent anyway? Is there really something that can be everywhere at once? Sounds like something I want to be…

Well, speaking about ubiquitous language, naturally we are talking about a metaphor. And after reading about ubiquitous languages in Eric Evans book Domain Driven Design and having combined this knowledge with my own experiences in software development, the pieces actually fall together.

Ubiquitous language is all about sharing a common terminology between people. This is an extremely important ingredient in how we communicate with each other. Without a common terminology there is no way that anyone can explain anything to anyone else. Or at least it will become a very, very difficult thing to do.

Let me take an example of this. Imagine that you are about to explain to you six year old son how he is to ride his new bicycle. Only that you are not allowed to use any words that actually describe such things as pedals, wheels, and stepping on the pedals. Of course you can always point at the things and call them “thingie” but try doing that as you let go of the bike and let him take off on his own. Well, he is bound to crash the first couple of times anyway so I guess this doesn’t matter that much…

It is hard to find good illustrative examples, isn’t it? Well, I am working on my imagination in this area.

Anyway, in software development we have something that is called the domain knowledge. This is the core business knowledge that is associated with the application(s) to be built. Each company have their own business knowledge and thus also their own specific terminology for it.

However, unfortunately the same terminology is not always used across the company and towards customers. Marketing people will use some terminology when they speak to customers when they originally sell the terrific idea. Then developers probably name those very same things to something similar in the domain architectural design. Then suddenly, further down the road, marketing renames a domain term to something else much cooler and, u-hu, the developers are doomed… They feel that this name change is just not worth the pain of changing it in the software design also. Especially this is common when we are talking the database with live production data. Ouch, do not touch it, it may fall apart and it is deadly vulnerable, the heart and soul of it all etc… Once this name conflict has occurred, the terminology is not shared any longer. Instead all developers have to map their domain names to what marking people means with the provided functionality. This is an utter source of confusion.

Of course, a name change is not the only reason for a mixed terminology at a company and there are certainly most often more players involved than merely developers and marketing people. Lacking communication within a company or misunderstanding of the domain model is just as common source of a fractioned terminology.

So where does ubiquitous “thingie” come in? Well, the terminology that we use to communicate with each other should be as understandable and sharable as possible to everyone so that the same words for describing domain knowledge are used. Then we have a much better chance of actually understanding each other. Trying an illustrative metaphor again; it means that we could concentrate on fitting the puzzle together with the help of the puzzle images instead of trying to do the same thing merely using their geometrical size. At least this is the sensation I get when working in such a domain at a company.

If you know of and understand the domain model and you are about to explain it to new-comers in the project, then my advice is that you start with explaining the terminology being used in a document. This will make it easier for other to understand the domain since they can start by reading this before they get an explanation of what the applications actually does. Otherwise, you will most likely use specific domain language words in your verbal explanations that they have not have heard of before. This will probably make your audience miss the main points you are trying to get across.

Also, by extracting and writing the terminology you will get a better perspective of the domain that you consider as natural and simple but perhaps is not. Most likely, you will find names that are confusing and duplicate names meaning the same thing. If so, revise the terminology so that it is correct and up to date. Make sure that this is the terminology that is used throughout the company by discussing with people. Then you achieve a ubiquitous language which will let you stay focused on the real problems and how to solve these.

The curse of regions

2007-11-22T23:30:47.403+01:00

I guess this is quite a dramatic blog title statement but unfortunately it is true. I am often cursing over regions I find in other peoples code. This blog post will tell you why generally I don't like them.

Both C# and VB.NET allows for a feature called regions. Regions at class level may look something like this:

Now, the benefit of using regions is that you may collapse them easily when you are not currently working with them. Many regions could then look like something like this

Of course, in a real scenario, you would have a more real case choice of selecting regions as to group class members. I’ve seen that it is common to group methods and properties etc. according to member accessibility level, i.e. private, protected, internal etc. Also, it is quite common to group regions of common member functionality; kind of like having inner classes but categorized as regions instead.

To make things worse, C# allows regions to be defined within members too:

So, how come I don’t like this? Well I have a couple of reasons for this:

1. Regions at class level make the code harder to work with. I think most advanced (lazy :)) .NET developers know that the Visual Studio short cut keys Ctrl + M + O collapses all methods and regions in a class. This action gives a quick and good overview of either the members or regions in the class. Even though you may expand/collapse a specific region with Ctrl M + M, it is quite a hassle to have to expand both regions and methods to get an overview of the actual code within the method. I think that an overview of the functionality of a class is best given by the natural language constructs themselves without using regions. Once you start adding regions to you code, you add an additional expand/collapse step in order to be able to start working with the actual code within you methods. This makes the code harder to work with.

2. Often, when regions are used at class level, it is done because there are too many members in the class to keep track of. This means that the cohesion of this class is low which is bad. Another, very similar principle, founded by Robert C. Martin, is the Single Responsibility Principle. Regions tend to make you violate this principle since classes become too large and contain too much mixed functionality. More on this in a future blog post…

3. Regions within methods share a common symptom. When regions are used within a method, it is likely done so because the method is very long. Too long if you ask me. Methods should be short and be easy to read and understand. Otherwise they will break what I usually call the Divide and Conquer principle. In short Divide and Conquer in software design, as I choose to define it, is a major problem split into many smaller problems by decomposing a method into many smaller methods. This is how you understand and solve a major problem a lot easier since you don’t have to be keeping too much detailed information in your mind at the same time.

4. When you use regions within a method, it is much more difficult to track the actual data flow between different regions. If local variables are used, and not state fields, you can easy see the API for each method. I.e. you see what input data each method needs and what output data it delivers. Regions within methods do not give you this and the code becomes much more difficult to understand.

5. Regions within large methods have another problem: if you receive an exception in operation and if you are logging the stack trace of the exception, you have a much more difficult time to track where the actual error occurred. With smaller methods instead, you will at least receive information in which method the error occurred. (…and of course you should not compile your code with the debug flag to true in operation environment…)

Well, these are the negative consequences of regions that I have come up with so far. Of all these negative aspects of regions, I think the potential violation of Single Responsibility and Divide and Conquer Principles are the worst ones. From what I’ve seen, regions tend to make programmers forget that they are developing in an Object Oriented language and instead program as if using a functional programming language. Sure, functional programming languages have their strengths, but improved readability and therefore better maintainability is not one of them.

So. Is there a place when regions actually are ok to use? Well, if someone has placed a region to group some less significant members of a class, I might accept it although I probably would not define the region myself. However, I will never ever accept regions within methods since I think this violates the principle of Divide and Conquer.

Though, I have found one case when I actually use regions myself. I find them excellent to use when I am constructing demos for course material. Regions let me hide code and comments that I don’t want my students to see yet. Alas, I use regions strictly for educational purpose. Wouldn’t the world be a better if everything just was a big nice demo…. :) However, it is not. So lay off those regions in your code. Please.

Web 2.0 - an introduction of mine

2007-11-15T23:37:04.076+01:00

I started out the chronicle that I recently wrote giving an angle at the information society we live in today. This is also what I will cover as a starter in this first web 2.0 blog post.

For developers, the information society is very real indeed since the knowledge base required for programming is huge these days. I have only been in the industry for about 10 years, but even in this time I can surely notice the change from when I began. In the .NET field alone, which is my field of specialty, there are thousands of classes that are good to know of. It is not always that documentation provided from Microsoft covers the need that exists. Also, the number of frameworks, libraries, components, third party open source products, tools etc seem to have exploded the last couple of years. It is not easy these days to call yourself an expert developer of .NET; Nor in any other programming domain for that matter. Most, if not all, people don’t call like to be called experts in such a broad field because of the expectations it may raise. My experience is that an overall humble attitude resides when it comes to programming knowledge nowadays. Something that is quite alright I think. We should be humble for the unknown I think. :)

Anyway, for developers, the provided information on the Internet has become a reliable source of information. This includes blogs, communities, articles, wikis etc. There is less of a need for developers today to keep track of all intricate details of language and frameworks since there are so many resources available out there. So many people share their experience in blogs and communities which many times makes is quite easy to find a solution to a specific problem.

However, we do have to distinguish between semantics and syntax. Syntax being the language we program in and I dare to say knowledge of the Frameworks provided to us; Semantics being how we program in the language and Frameworks. Both types of knowledge are to be found on the Internet. Semantics, however, is so much harder to learn than syntax knowledge. Semantics deal with the architecture and the design of software and this takes knowledge (lots of reading) and experienced practice (lots of programming). We are talking years of studying and programming in a professional domain specific environment. The funny thing is that even though I think I’ve reached perhaps the middle of the tunnel, occasionally it seems like I am thrown back to the start of it due to some new experience or gained knowledge. What other profession allows you from time to time to have the sensation of being a rookie again? :) To me, this is fun. And frustrating.

Well, this blog post kind of made the introduction of what I am hoping to become a series of blog post in the web 2.0 field. I have many thoughts to share, especially when it comes to wikis as software development tool in software projects. So stay tuned for upcoming post if you’re interested of my thoughts.

Reagrding the Computer Sweden chronicle

2007-11-15T23:10:33.803+01:00

For about a year now, I have on a monthly basis been writing a chronicle for the Computer Sweden magazine. I receive a software developer related question in various software areas each month. Most of these chronicles can be found here, but you will need to be able to speak Swedish in order to understand them… J

However, each month I do end up with the same kind of struggle: to shorten the chronicle to the text length I am allowed to have. There is absolutely nothing wrong with this. On the contrary I think a chronicle should be enjoyable and somewhat light weight to read, not covering too much details and especially not be too lengthy. In short: enjoyable to read. Don’t know if I accomplish this really but I do my best.

However, it is really difficult and a very special art of writing to be able to be precise and tell something meaningful on a limited length of text. I believe it was August Strindberg, a quite famous Swedish author who once said: “I do not have time to write short”. Now, I am definitely not comparing myself with Strindberg but I do understand what he means. All too often I have been writing emails to my colleagues at Dotway that perhaps have been a few pages to long (pages being a metaphor obviously... J ). Some colleagues have even coined such long mails as “Tobias mail”… all to my utter frustration of course. I dare to say that I really do try to shorten long mails down, but sometimes this just takes too much time to go all the way. I always do spend long times reviewing such long mails so that the structure is ok and understandable and that spelling and grammatical is ok. Anything else I think would be disrespectful to whomever I am writing to since I am opting for precious time on my account.

As a side note: The last couples of month I have a couple of times successfully changed tactics going from quantity to multiplicity … J Maybe this is the road to take.

When it comes to the Computer Sweden chronicles, the editors leave me no choice and I really have to spend time to be brief and consistent. Even though I occasionally has slipped the quota and received a gentle and friendly mail distributed slam on my fingers from the editors, most often I have been able to keep myself at a maximum of 120% of allowed text length... Anyway, I am thankful to the Computer Sweden for giving me this opportunity to practice being brief and nail those specific points.

So why am I writing all of this? Well first of all because it is my blog. I can write whatever I want in it without bothering if people will read it or not. Second of all, in the last chronicle I wrote, which is supposed to be published soon, I did add a reference in the end of it to my own blog. Why? Because the topic, web 2.0, is huge! I actually have a lot of more thoughts on the subject than what I could fit into the chronicle. And the chronicle being a web 2.0 chronicle, it seems like the perfect ending for it too. J So after this --- ehem --- rather lengthy blog post, I intend to get right at writing a blog entry about web 2.0.

DasBlog 2.0 and skin

2007-11-15T22:59:43.49+01:00

This week I finally did something about my blog engine. I have gotten tired of the DasBlog skin I was using so I found another one that I liked. So finally, I downloaded the last version of DasBlog v2.0. It was over 2 and a half years since I looked at the source code the last time (open source) and it seems like people have been doing a great job since then bringing new functionality to it. I am not sure if I like/understand everything that I see in the code yet, but it is definitely an amazingly good open source project. Many thanks to those of you who have contributed with your time to make this possible!

Btw, there might be some errors still on this new site of mine due to missing configuration, so please let me know if you find one. Promise I’ll buy you a beer next time you’re in Gothenburg if you do ;)

Silverlight seminar in Gothenborg, Stockholm, and Linköping

2007-10-25T15:11:19.3501925+02:00

The 8^th of November Dotway will give our first breakfast seminar in Gothenborg. It is free of charge and everyone interested in the subject are welcome. I know that my two collegues Björn and Truls have moslty looked into the 1.1 version and it is going to be a thrill to see it for me also. This is actually Dotways first "seminar tour" in Sweden and the seminar will be given in Linköping later on during the afternoon and in Stockholm on the 9^thof November in the morning. You can read more about it here: www.dotway.se/silverlight.

So far I've only got 6 people signed up and I know they have had a full house twice in Malmö. ;( Well, well, hopefully more people will hear about this. The more, the merrier I think. ;)

Code and slides from MVC presentation at Pimp My Code

2007-10-24T23:00:34.498+02:00

Wow! Emabarrasing. I didn't realize it was almost a year since I made a promise to keep writing in my blog... Ok. Now I make a new promise, here and now: to never make any promises about writing in my blog. That's definitely a more easy one to keep. Allthough I do actually have a lot of subjects piled up that I want to write about and I hope that I can get started at it in november. But that's not a promise.. :)

I have just spoken about Model View Controller at Pimp My Code that Cornerstone arranged. Yesterday in Stockholm and today in Gothenburg, Sweden. It was a great event and my brain is boiling down all the impressions I got during these two days, Both from hearing the other, in my opinion, excellent speakers but also just from the atmosphere during those two days. Hopefully I will get to do this again.

Anyway, I did promise to hand out my code demos in my blog and here they are: MVC demos.7z (167,42 KB).
(Download 7-zip here). I was worried for a while since out of convenience I placed the SQL Express server database (files) in all projects that needed it. Well, the database had a size of about 2 MB (although very little content) which rendered a total size of about 23 MB.. But 7zip did an amazing compressing job so I think I am home free.

Now, some words about the demos. I did write them all this weekend and rather hastily. I did do some refactoring as I created the next demo and so on, but I did not bother to clean up the old ones. But the total code mass is so small as it is so that should be no problem to you. Also, I wanted the demos as clean and simple as possible in order to demonstrate different aspects and flavours of Model View Controller. Hopefully I did manage this. Although I do admit I would have liked to tidy the code a bit. But what the heck. Enjoy or destroy. :)

Nevertheless, feel free to contact me if you have any question about something. My name is tobias.fjalling and I work at dotway.se. I think you can figure out the rest. :)

Here my powerpoint slides too: MVC.pdf (0,4 MB)

PS. I just gotta do something abour this crappy blog GUI of mine. This is embarrasing too...

Öredev 2006 AJAX workshop part I

2006-11-20T23:24:13.225+01:00

Last week, the Öredev 2006 conference took place. I though it was a great event and I listen too many interesting speakers. I'll probably get back to write some reflections on some of the sessions in later blog posts. My own workshop session took place last Tuesday and I was assitested with Göran Halvarsson at Dotway for this session. I thought the workshop went fine although I have'nt taken part of the workshop evaluations just yet.. As I been writing previously, the workshop was based on the ASP.NET AJAX July CTP rather than the newly released beta 2 version. Not that it mattered that much I though since the concepts are the same.

I just sent the workshop labs and the instructions for the walkthroughs to Michael Tiberg, the project leader of Öredev, so they should be dowloadable from the Öredev website soon. However, I've put in a lot of effort to convert the labs into the beta 2 syntax. This is quite cumbersome since much of the client control documentation still is missing at the ajax.asp.net web site. I'm almost done however, and I promise I will write about my endevaours with this matter in a future blog post.

a rightful confession...

2006-11-09T23:32:08.377+01:00

I've been so tuned in lately on upgrading a .NET introduction course for Dotway, the company I work for, that I've totaly missed out on the ASP.NET AJAX beta 1 release that occured the 20^th of October. Feeling a bit embarassed about this I'm currently catching up on the news also in this release. As always, Scott Guthrie writes a spendid summary of the features in his blog. A lot of the features I found new in the beta 2 release yesterday apparantly were already there in the beta 1 release. Ohh, and sure, Scott writes an exellent summary on the beta 2 release as well.

So I'll be using my weekend to look through the changes that have been made, especially considering the Öredev AJAX workshop comming up on Tuesday. Yippidiye! :)

ASP.NET AJAX extention beta 2 released

2006-11-08T22:33:16.17+01:00

I'm definetly not the only one blogging this news, but ASP.NET AJAX beta 2 has just been released. This would probably mean that we are not far from a final release. This version is said to be feature complete although there already is a CTP version available with some parts that are being worked on. (I'll probably get back with info on what.) My tip of the hand is 2-3 months.

I've just dowloaded the beta 2 and I haven't yet dug into it to see what changes there are since last CTP. But there is one thing I'd like to reflect upon already now. When installing the beta 2, it actually states ASP.NET AJAX extention. So we see that the ASP.NET AJAX will be completly integrated with the regular .NET Framework. My bet is that with time, ASP.NET AJAX will be a natural part of ASP.NET. Also seing in the release notes, that the
Oh well. Time to get my hands dirty.

Almost forgot. The .NET Framework 3.0 has just been relased too. But I'll refer to a collegue of mine for this news.

Long time, no write..

2006-11-08T22:13:57.2787282+01:00

It's been a while since I last wrote something in my blog. Last time that happen was just before the Developer Summit conference in the beginning og June. The workshop went very well and I was quite happy that I had put soo much work preparing myself and the material. And guess what! next week I will be doing the workshop once again at the Öredev conference in Malmö on the 14th of November. Actually it is a pre-conference workshop day. This time I will get some assistance of my collegue Göran Halvarsson and since it looks like it's going to be fully booked I most likly will need it.

So why have'nt I blogged in a while? Well, actually, after the Developer Summit conference in June I went on long vacation for ... 13 weeks. Actually I was'nt only relaxing during this time, but did a different kind of work singing in the opera choral here in Malmö. My first visit in a professional choral was a great experience and hopefully it won't be the last time. We were doing Verdis Nabucco in Denmmark. A very intense choral
piece so I did spend a lot time this summer studying Italien lyrics. Weird. And difficult. Not at all like programming actually... So after this I really have'nt come around to write in my blog althoug I've been back at my regular work for some time now. But that is going to change now I hope... Here we go!

AJAX/ "Atlas" workshop in Stockholm

2006-06-02T09:14:30.615+02:00

This afternoon I am holding a workshop on developing web applications with AJAX / "Atlas"in Stockholm at the ExpertZone Developer Summit 2006 conference. I've been preparing the material for quite some time now and I fell very exited for the afternoon. Unfortunately my collegue Göran Halvarsson is sick though so I am sure I will be quite busy with som 30 workshop attendees. Well, anyway, I'm sure it's going to be a lot of fun. :)

ASP.NET 2.0 presentation in Malmö

2005-05-05T23:50:19.992+02:00

This is kind of a late notice, but on Tuesday the 10th of May, I will be holding a brief ASP.NET 2.0 presentation in Malmö, Sweden at the company I for: Dotway. A collegue of mine is also presenting Windows Forms 2.0. If you understand Swedish :~) and if you are interested you are much welcome. You can read more about it here.

An unusual hour at work and the help of a heavy wallet...

2005-05-03T23:36:22.106+02:00

Today, I ran across several disturbing usability issues using the version handling tool ClearCase. I was to deliver some bug fixes I've made in an older version of an application in a developer stream to a newer version of the application in another stream using the deliver to alternate stream operation in QlearCase. This is certainly a very valuable operation and since this was the first time for me doing so, I was full of steaming anticipation. I thought, "...just a few clicks and I am home free. No cut 'n paste the ol' fashion way. Hell No!"

I had three bugg fixes in the old version. I figured that I could select these three specific work orders, click on deliver to alternate stream and voilá: I'd get some nice merge code screen shoots in which I could select the code to deliver to the main integration stream in a simple way. I've seen and used the merge view in ClearCase before so I knew this would be a breeze.

First issue: ClearCase would not let me choose only the three work orders that contained my bug fixes. I had to pick all work orders, including some other irrelevant stuff that I didn't want to integrate to my main integration stream. Ok. Fine! I'll do so imagining some extra clicks here and there in the merge view.

Some ~250 click procedures later in the merge view, an increasing awareness arose that something was probably deadly wrong. I had been changing some Controls properties in my user interface which meant that many .resx files had been changed. Further more, I seem to have had my Visual Studio.NET project files checked out for either adding or deleting files. Ok, I'll take the pain I figured and continued to click away... All of such changes would be button number 3 anyway (see algorithm below).

Some ~350 click procedures later my brain, set to 'algorithm mode', started looking for a way of improving efficiency. I define the clicking procedure algorithm accordingly:

Step 1: Move the mouse to the "arrow" button.
Step 2: Click!
Step 3: Move you mouse to either button labeled "2" or button labeled "3". Decide this based upon the merge view. Mostly 3.
Step 4: Click!
Step 5: Goto step 1. :)

Anyone who has performed this algorithm a couple of hundred times knows that your arm gets tired from moving the mouse. It would be much nicer finding a keyboard shortcut for at least one of the clicks. And, voila! There it was: Alt + "Arrow right" for clicking the "arrow button". Now, most keyboard I know of, there is a certain distance between the 'Alt' key and the right arrow key approximately consisting of some 20 cm. If you don't play the piano or otherwise is skillful at playing the classical guitar, you will have to use two hands. It doesn't take an Einstein to figure out that my algorithm is worth crap with this approach. I still would have to move at least one hand back and forth. Issue #2 as you might guess.

Light bulb!!! Unfortunately it didn't come from me :o) but from a colleague of mine, Mattias Ask: "Put a heavy something on the Alt key." Tada! My heavy wallet finally found a superior purpose other than containing receipts and, thank good, heavy coins.

Damn! The speed is up! 400! 500! 600! 700! Heavens! Does it ever end? A growing suspicion in my mind tels me that it isn't and that I should chicken out and abort. Yes I'll do so! I dare no longer. Just think if something go wrong and I have to undo some 1000 click procedures manually in the code.... Oh, Abort, abort! --- Hey! Wait a second... There is no clear way of aborting this thing and perform a rollback operation. Guess what the third (!) issue is? :( Coming to some Rational sense, I realised there was never any risk of having to undo a thousand clicks manually. And I started to click away again.

Well, I did give up anyway. :o( Even though not so time consuming I never was much for repeating dull tasks. In the end I did find a way of aborting: just closing the merge views as they appeared finally led you to a button with some kind of abort labeling (forgot the exact name). Doing so makes it possible to continue at a later phase. Ok, so I tried that just to see if it was working. Sure enough it did. But ClearCase got confused with three of my remaining files and refused to accept my choices (button "3" off coarse). I guess that makes my fourth devastating issue. So in the end, after some perhaps 1000 click procedures, I ended up with a complete failure. Here we go: back to the good ol' cut 'n paste. Someone recalls my previous blog about technicians sometimes preferring to do things as done before?

I don't like this at all. It seems to me that this should be working, if doing it right. And the fact that it didn't bothers the hell out of me. The most important lesson would off course be to have only one bug fix as one work orders to deliver to an alternate stream. But since I always would have to do this merging graphically there is still one problem as I see it. The main stream containing the later version of the code has normally some continued developed code (that’s why it is the next version, ehh!). And if a delivery from the developer stream to the integration stream has to take place, there normally should be lots of differences between the two versions. In essence meaning many click procedures. I would very much like some ClearCase expert to give me some answer to this question and some advice of 'best practices'. Hello world! Is anyone reading?

Some elaboration on what, where, how, and finally why

2005-04-30T23:47:21.879+02:00

When I came up with the blog title I figured that I would explain in some more detail what I meant in one of my future blogs. And when I experienced one aspect of what I mean so clearly on a workshop this week, I thought I'd take the opportunity to write about it. I better warn you that this blog is of a more philosophical nature. If you are not in the mood for this you better stop reading right now… :)

But before this, as a small taster I would like to add a personal background which might illuminate my standpoint further. Some 6 years ago I acquired a Master of Science degree in Electrical Engineering. Such an educational program includes many different technology areas; A big package of mathematics, physics, electronics, computer programming, etc. All of these technology areas share one common approach of how to pass a course examination. Some problems are to be solved in a preferable way. Looking back, I remember facing the following questions for each new course: What is the problem, where is the knowledge that helps me solving the problem, and finally how do I solve the problem. It is obvious that by repeatedly dealing with these questions in various technology areas you train the ability to extract important information, analyse it in a correct way, and then finally act upon it. The essence of this is that the approach is general no matter what underlying technology is being used.

Looking back now I am happy that I have learnt a technique of how to approach these questions. But I feel that often there was one question missing: why are we solving this problem in the first place? During those years of studies, the answer was intuitively there most of the time and I didn't even have to address the question. But in real life, and perhaps especially in the software development community, I feel that the question why is so much more important, and unfortunately also sometimes difficult to answer. Because when we building a “machine” that in some way or another is to help people, the ground base for its success is all about the interface between the man and the machine: MMI.

Now, I am not saying that programmers tend to forget the important question of why the software is being developed. On the contrary, I think most programmers are very interested of what the purpose is for their developed code. But I do think that we tend to narrow the field of possibilities by immediately thinking in terms of how we should solve the problem. In turn I believe this limits our creativity in terms of HCI aspects. I further believe we tend to stick to solutions that we have implemented before, that we know of and thus also are in control of. Certainly this is valuable since reusing old ways of thinking is both time saving and less prone for failure. But the question the developer always must ask himself is "Are we really meeting the purpose of the software". In essence: Why do we develop this software?

During the workshop this aspect was so clear to me. I held a presentation and demonstration for a group of people of a software application that I am currently involved in developing. This application is a bit special since it is to be used and integrated in many other applications in an enterprise environment. This is probably the worst case scenario for a program since it most definitely will mean that different and possibly even conflicting requirements are set for the application. Now, at the workshop there was me and some other guys from the IT department present. The rest of the people were all either business managers or business analysts as representatives from different application teams that were to use the demonstrated application. None of them I believe have a technical background, but all of them had a very in-depth knowledge of how their applications are to be used and implicitly and ultimately also why it is to be used. During the day, we were all discussing new future requirements of the application. As each new requirement was discussed, I could not help to think of in terms of how it could be implemented. This in turn might have narrowed my mind in terms of end user possibilities.

Now, I believe I am a true-minded technician. And for me not think in terms of possible solutions when I hear a requirement… Would that not be like waving a banana in front of a monkey and asking him to look the other way… ? ;-)

So. In conclusion: I am not saying that we technicians should not think in terms of “how to solve things” when we hear of new requirements. And perhaps thinking in terms of how to solve things should always be our role in the process of creating the perfect software (Is it doable?). But I believe we should always try to be as open minded in terms of possible solutions as possible and that we should have a huge amount of respect for people with better knowledge, understanding, and experience of dealing with this very question. And we technicians should certainly never believe that we understand the reasons for the existence of the software better than anyone else just because we know the details of its current behavior better than anyone.

Having written all this, I have a feeling that perhaps I have just stated something that is evident for all people, including technicians. But I’ll think I publish this blog anyway. Perhaps I come back rereading it in five years and laugh at my thoughts at the time. Or perhaps not…

My first blog...

2005-04-17T23:51:57.892+02:00

My first entry in the blogosphere. Don't know if this initial blog will be my only one and if I am to become one of these one-time blogger wonders out there. Neither do I know if softwareandwhy.blogspot.com will become my permanent webadress, but I'll be sure to leave a reference to my new place if I change.

So here I am folks! For everyone and especially noone to read. :)