Vukoje's blog about software development

There
are lots of things that can be documented in software development. That doesn't
mean that you should document them all. You should document things that are
important and specific, things that everybody working on project should know
and that you will forget if you don't write them down. Most important
things that should be documented are:

project vision

requirements

architecture and code

Project Vision

"The
Vision summarizes the "vision" of the project. It servers to communicate
the big ideas regarding why the project was proposed, what the problems are,
who the customersare, what they need,
and what the proposed solution looks like. The vision defines the customer’s
view of the product to be developed, specified in terms of the key needs and features.
Containing an outline of the envisioned core requirements, it provides
contractual basis for the more detailed technical requirements." [Craig Larman, Applying UML and Patterns]

Project
vision can be one page document describing why is project being built, what are
customer needs and what is the firm’s benefit. Once project vision is
clear to all team members, it will be easier for everyone to focus on project
business value and everyone will be able to contribute to project. After all,
we programmers are not there to put buttons on forms; our task is to solve
customer’s problems.

"Programmers
who remember to consider the business impact of their decisions are worth their
weight in gold."

Project
vision is so easy to create that it may seam to obvious, but what is obvious
know won't be in one year, and what is obvious to project leader may not seam
so obvious to rest of the team. Writing one page document to explain 6
months project to 20 people shouldn't be a problem.

In my previous
blog post I've said something about the reasons of documenting software. Now the question is how to do it?
People don't like to write documentation, documentation is often hard to find
and maintain and it is usually obsolete. We need to organize documentation in
such way that it is meaningful, easy to maintain, easy to find and hard to
become obsolete. You can say that right solution is somewhere between full
bureaucracy and anarchy.

Process oriented solution

Some
people believe that with detailed organization and business processes they can
completely controls their business. This approach is something like programming humans that are executed by
business process. In this environment programmer would have to follow exact
documenting process and typically fill big documentation templates with
concrete information. This procedure can guarantee that people will avoid documenting at all costs and it
doesn't guarantee that information populated in templates will be useful
enough. It may give away false impression of fully controlling this vital
activity but in practice it isn't so.

Programmers
dislike (hate) writing software documentation because it is not interesting and creative. If they are further more crippled
by heavy formal process, programmers will do what ever they can just to finish
that part of work by filling templates with low quality and incomplete
information.

If it is not easy for programmer to find
and update some information he simply won’t do it (if he is not explicitly
asked to do it). As software evolves and knowledge of the real system
increases, documentation becomes obsolete because programmers are not updating
it. After enough time has passed you are faced with massive obsolete documentation that in the end of the day is making
more harm than good because you can never know if information is accurate.

People oriented solution

My opinion is that company Wiki site (e.g.
ScrewTurn Wiki )is much better solution for knowledge base than bunch of populated
word templates resting on some server's file system. Pages on Wiki site are easier to search, easier to alter and they can automatically
notify all participants when documentation changes. This approach can seam
frightening to management because everyone can alter any document they want. In
general, employees shouldn't be constrained in their work so that they can not make mistake. Not being able to make
mistake means that you aren't doing any creative work and that you should be
replaced with machine. Instead, company should introduce quality checks for
activities that are more likely to introduce an error or where error can be
very expensive. Some dedicated person (e.g. project leader) could inspect all
documentation incremental changes in previous weak and verify them. Bear in
mind that almost all Wikis will automatically store document versions and track
changes. This way person who made mistake can always easily be identified and
document can easily be rolled back to previous version.

After you created infrastructure for easy and fast document manipulation you
still need to create firm climate
(culture) to motivate people to contribute to knowledge base. This is the
only way that firm knowledge will grow and knowledge will be effectively passed
between coworkers. After all, what are knowledge workers
without good knowledge base?

In my next post I will write about what should
be documented and how, so if you are interested hook up to my blog feed and stay tuned.
What are your experiences with writing software documentation?

First theme I will write about in this blog is software documentation. It feels like natural starting point or at least it should be. Documentation must exist in some shape and volume before you start with development. Documentation purpose is to capture knowledge, keep it from misconception and forgetting. It is important for all participants in software development life cycle, from customer, through PM, developers, tester to users. All of this sounds logical, we have all been taught these things.... so what's the problem?

The Problem

Problem with documentation is that its creation can be boring and documentation can easily become out of date and useless. Documentation also takes lot of time, which is taken from development. After all, you can not compile and run your documentation. Because of this, people can easily forget importance of documenting one highly complex system, where misunderstanding is happening on every day basis, and will easily drop it in background when time becomes critical factor... and time is often critical. At the end of the day/deadline, if needed functionalities don't exist, existence of documentation is irrelevant. It is interesting that writing documentation is not problem only to developers urging for freedom and creativity, it is also problem to customer. Customer would usually say that of course he wants his software documented, but at the end of the day he usually won't be willing to participate in its creation, updating and clarification.

The Need

Now that I covered some of the problems with documentation there is a question "Why should we bother with writing documentation?”. One of the main attributes of software is complexity. Software is usually built to automate some business processes and handle some system complexity transparently. We can say that there are several complexities in software development:

Domain Complexity - natural complexity of domain for which software is made.

Application Complexity - complexity of application design. This is artificial complexity that can be added for greater reusability, maintainability or can be added by accident.

Technology Complexity - complexity of tools and technology used for development.

So we already have three sorts of complexity. That is a lot and only one of those can be pretty large. You should also note that domain can be fairly unknown to customer him self. He could also fail to explain domain to developers, or developers can misunderstand him.

Application complexity can be pretty complex as initial design on paper, with no coding. As system grows, requirements are changing, code is changing, as time runs out developers are hacking their way through code... In worst case, application complexity can reach so high level that no changes are possible and project is dropped. As for technology complexity, we all know that technology is changing which doesn't mean it is advancing.

From all above we can conclude two things:

Software development is hard.

Software documentation is very much needed.

In next post I will be covering some advices on writing documentation so hook up to blog feed.

I was always wondering how someone can have enough time to write some blog with
rich content. Meanwhile I have accumulated solid amount of knowledge which
I don't have with who to share. My friends and family don't plan on learning
some programming language, and I don't get to see my friends programmers often
enough so we could spend all of our time talking about work. My wish is to
share my ideas, findings and thoughts on this blog and to hear your opinion
about them. IT is to complex to be tackled down without synergy.