how to perform certain code on specific time in android?

Are there any research papers about effects of writing documentation and commenting code on software quality, maintainability, and team productivity?

• I am an advocate of commenting on source code and documenting software products. It is my personal experience and observation that working on source code that is rigorously commented has helped me in different ways when I have had to grow software or maintain it. However there's another camp that says commenting is ultimately worthless and its value is questionable. Numerous proponents of coding without commenting argue that: If a piece of code is well-written, it is self explanatory and hence does not need commenting If a piece of code is not self-explanatory, then refactor it and make it self-explanatory so that it does not need any comments Your test suite is your live documentation Over time code and comments get out of sync and it becomes another source of headaches Agile says working code is more important than piles of documentation, so we can safely ignore writing comments To me this is just dogma. My personal observation has been that software written by teams of smart and experienced developers ultimately end up with a considerable amount of code that is not self-explanatory, looks ugly, and needs courage to touch. The Java API, Cocoa API, Android API, etc. show that if you want to write and maintain quality documentation, it is possible. Another argument here is that these are APIs for libraries and frameworks, not for end-products and That end-products (software that rely on these libraries and APIs) do not need documentation and commenting. Having said all these, conversations about pros and cons of documentation and commenting on source code that are based on personal beliefs usually do not end well and lead to no satisfying conclusions. As such I am looking for academic papers and empirical studies about the effects of software documentation, especially commenting source code, on its quality and maintainability as well as its effects on team productivity. Have you stumbled upon such articles and what's been the outcome of them, if any? EDIT: I am adding links to related articles that I find here. Some are just opinions and editorials though. http://queue.acm.org/detail.cfm?searchterm=source+code+comment&id=957782 (ACM)

• Answer:

  I have always found writing documentation results in cleaner, better-constructed code because you have to think about what you're doing. In a large development environment, with multiple development branches between developers, poor documentation is an absolute guarantee for incompatible code and patch conflicts. In code bases that are highly stable over long periods of time (10-15 years in some of the cases I've seen) and where this means no subject matter expertise exists, refactoring code without side-effects (Heisenbugs, usually, but also entirely valid but undocumented external references) is dangerous and requires extreme care. You don't just go in there and do it, even perfectly good, perfectly compliant code can affect things out of scope. Such situations often cascade. Fix one supposed flaw, create two or more new ones. It's not the code that's wrong, it's the understanding. Code with extremely high levels of correctness use code verifiers that compare what you say you think you've written with what you've actually written. In other words, they work because the code has been commented. Take a look at Spark 2012, or the SEL4 microkernel for how to use contract-based programming of this sort. Agile is not necessarily a good way to produce clean code or robust code. Although certainly not representative, when I've been brought in to fix a company's software, every case has been a case of code produced by Agile. Please note, this is not a defect in Agile, it is a defect in the use of Agile. The method, if misapplied, produces terrible results. Even correctly applied, I'd not use it in anything Mission Critical. It's a convergent method, it's great when you don't have true specifications and must evolve rather than engineer. But there's a price to be paid, which is that it IS evolutionary and convergent, you're never "there" and you're never quite sure what "there" is anyway. Do coders like documenting? Usually no, but if you took away the documentation they relied on (there'll be bookshelves and half a desk surface of the stuff), the air would turn blue and it's quite possible you will witness spontaneous human combustion. No coder likes to write it, but no coder can survive without it. One thing you've got to understand is that most of us get absorbed, hyper-focussed, on the tasks. We forget that the manuals on which we utterly depend we're written by people just as absorbed and just as loathing of writing. We forget development isn't iterative but recursive, that someone depends utterly on the manual we're damned and determined not to write. There is no such thing as self-documenting code, coders are no better at writing test harnesses than they are at writing manuals, and if I'd a penny for every broken patch merge I had to manually fix, I'd have $143 and 19 cents.