Happy Are The Software Engineers.. (article)

My first ever published article is called "Happy Are The Software Engineers.." and it appeared in Better Software magazine in December 2006. The article describes briefly how complete concentration can create the feeling of happiness especially if the task at hand is meaningful. I wanted to highlight that working for software quality is meaningful and with Tick-the-Code you can achieve complete concentration.

Simply put, happiness is Tick-the-Code.

Tick-the-Code Inspection: Theory and Practice (paper)

My first ever scientific paper is called "Tick-the-Code Inspection: Theory and Practice" and it appeared in the peer-reviewed publication of ASQ (American Society for Quality) called Software Quality Professional.

As the name says, the paper reveals all details of Tick-the-Code up to the 24 coding rules. At the moment this paper is the most comprehensive written source for information about Tick-the-Code.

Tick-the-Code Inspection: Empirical Evidence (on Effectiveness) (paper)

My second paper is called Tick-the-Code Inspection: Empirical Evidence (on Effectiveness). It was prepared for, and first presented at, Pacific Northwest Software Quality Conference 2007. The paper presents measurements taken in Tick-the-Code training courses so far (about 50 sessions with over 300 software professionals). The results are revealing. The main point of the paper is that software engineers could keep their software much simpler and avoid making many of the errors software projects are so notorious for.

In the Appendix of the paper, you'll find all the active rules of Tick-the-Code at the time of writing (summer 2007).

Tick-the-Code - traditionally novel technique in the fight against bugs (article)

Pirkanmaan Tietojenkäsittely-yhdistys (Pitky ry) published my article in their member magazine Pitkyn Piiri 1/2008. It is called "Tick-the-Code - uusvanha tekniikka taistelussa bugeja vastaan" and it is only available in Finnish.

An Example Rule Introduced

There are 24 active rules in Tick-the-Code. Each one of them helps to locate either omissions, redundancies, ambiguities, inconsistencies or assumptions in the source code. Individual rule violations might seem minor, but when you let them accumulate long enough, you'll be in trouble.

Marked rule violations are called ticks. Try the following rule on your production-level code and see how many ticks you can find. Then analyze each tick and see if you can't improve the maintainability of your code.

The rule sample changes weekly, so in a mere 24 weeks of diligent visits, you can have yourself the complete set of Tick-the-Code rules. However, there is an easier way and you'll be rewarded with laminated rule cards to top it all up. Get trained! Contact Qualiteers if you want to know more.


"Each routine shall check its input data."

Input data are parameters, member data and global variables (*shudder*) used in a routine. Each routine must make sure before using any of the values that they are usable. Sometimes a value must be within a range, sometimes a pointer address can be approximately known and when a value doesn't check out, any further processing is stopped. This is called defensive programming. The assert macro is an excellent tool for this purpose.

By the way, anything you can do with global data, you can do better with access routines.

Future Work

Tick-the-Code Inspection: The Book (book, working title)

Since 2006, there's a book on Tick-the-Code on the works. Currently the book project is on ice, as I study and gather more material and field experiences to include in the book. The book will be the most comprehensive written source on Tick-the-Code.

Excerpt from the book

The excerpt changes weekly. Each excerpt is still a draft version and might change before ending in the book.

Bloated testing

Software quality isn't automatic, especially in organizations not using code inspections. For them, testing is the only way to find out about the quality level of the project. Testing departments tend to be large and even if there aren't many testers, at least the time reserved for testing tends to be fairly high. In such organizations, all the eggs are in the same basket. There's only one quality method, testing.

Paradoxically, the high amount of man-power or scheduled time is not enough. This is the symptom. You have relatively much testing resources, but you still can't manage. Something is missing from the equation. The situation isn't balanced. Without the informative checkpoints provided by regular code inspections, a project can veer out of control long before testing can even begin. It is rather likely to hear constant complaints about under-resourced testing departments or not having enough time for testing.

The testing seems always to come late and the view is not completely false. Because testing comes after coding, any delays in coding will show up in testing. Any defects found in testing cause rework in coding, after which re-testing is necessary.

Sometimes testing uncovers critical problems very late. This might be because other defects have been masking the problems before. Testing needs to execute the code and as long as the code isn't executing, it won't get tested. For instance, defects that prevent using a certain feature, prevent also the testing of it. Any defects in the feature itself remain uncovered until the feature can be accessed. Code inspections don't need the code to execute, but that is a property test-only organizations lack.

(Warning! A literary reference is imminent. Shakespeare, Hamlet. Proceed with caution!) Just like in the state of Denmark, there's something rotten in the fatalistic thinking in test-only organizations. They think that all software faults are unavoidable. Testing becomes bloated because defects are inevitable.

"Because there are going to be many defects, we'd better reserve a lot of testing time"

is a self-fulfilling prophecy, which turns Steve McConnell's thought in the excellent "Code Complete" upside down:

"We haven't planned much time for testing because we're not going to find many defects."

The more time and resources you plan for testing, the more acceptable it seems to leave defects in the code. People, especially software developers, in test-only organizations seem to be convinced that testing will find the faults anyway, why bother trying to avoid them?

Another symptom in organizations focusing their quality activities on testing and not doing inspections is the animosity between testing staff and programming staff. This applies assuming there are two separate groups of specialists in the organization. From the testers' point of view the programmers are careless and leave too many defects in their code before testing. From the programmers' point of view the testers are mostly complaining about minor issues. The relationship between the groups is often fragile and the communication minimized. It is almost as if the two groups were enemies instead of working for the same goal of producing quality software according to the plan.

Hostile tester-programmer relationships, belief in the inevitability of software faults and huge testing departments desperate for ever more growth are symptoms of excessive dependence on testing. Code inspection as a new means to control software quality could relieve this kind of testing addiction.

Testing seems to me to be overestimated since it is not the cure, testing just points (approximately even) to the need of more careful working. Preventing errors, learning quickly from one's mistakes are the only possible ways of becoming truly better in software. With Tick-the-Code, it is possible, feasible and makes the job so much more fun.

Itchin' for a Drive?

Get your bearings:


Click for the sitemap.

Participants comment:

Actual training feedback

Click for training course details.