> -----Original Message----- > From: r-devel-boun...@r-project.org [mailto:r-devel-boun...@r-project.org] > On Behalf Of Paul Gilbert > Sent: March-31-12 9:57 AM > To: mark.braving...@csiro.au > Cc: r-de...@stat.math.ethz.ch > Subject: Re: [Rd] CRAN policies > Greetings all
> Mark > > I would like to clarify two specific points. > > On 12-03-31 04:41 AM, mark.braving...@csiro.au wrote: > > ... > > Someone has subsequently decided that code should look a certain way, > > and has added a check that isn't in the language itself-- but they haven't > thought of everything, and of course they never could. > > There is a large overlap between people writing the checks and people writing > the interpreter. Even though your code may have been working, if your > understanding of the language definition is not consistent with that of the > people writing the interpreter, there is no guarantee that it will continue to > work, and in some cases the way in which it fails could be that it produces > spurious results. I am inclined to think of code checks as an additional way to be > sure my understanding of the R language is close to that of the people writing > the interpreter. > > > It depends on how Notes are being interpreted, which from this thread is no > longer clear. > > The R-core line used to be "Notes are just notes" but now we seem to have > "significant Notes" and ... > > My understanding, and I think that of a few other people, was incorrect, in that > I thought some notes were intended always to remain as notes, and others > were more serious in that they would eventually become warnings or errors. I > think Uwe addressed this misunderstanding by saying that all notes are > intended to become warnings or errors. In several cases the reason they are > not yet warnings or errors is that the checks are not yet good enough, they > produce too many false positives. > So, this means that it is very important for us to look at the notes and to point > out the reasons for the false positives, otherwise they may become warnings or > errors without being recognised as such. > I left the above intact as it nicely illustrates what much of this discussion reminds me of. Let me illustrate with the question of software development in one of my favourite languages: C++. The first issue to consider is, "What is the language definition and who decides?" Believe it or not, there are two answers from two very different perspectives. The first is favoured by language lawyers, who point to the ANSI standard, and who will argue incessantly about the finest of details. But to understand this, you have to understand what ANSI is: it is an industry organization and to construct the standard, they have industry representatives gathered, divided up into subcommittees each of which is charged with defining the language. And of course everyone knows that, being human, they can get it wrong, and thus ANSI standards evolve ever so slowly through time. To my mind, that is not much different from what R/core or Cran are involved in. But the other answer comes from the perspective of a professional software developer, and that is, that the final arbiter of what the language is is your compiler. If you want to get product out the door, it doesn't matter if the standard says 'X' if the compiler doesn't support it, or worse, implements it incorrectly. Most compilers have warnings and errors, and I like the idea of extending that to have notes, but that is a matter of taste vs pragmatism. I know many software developers that choose to ignore warnings and fix only the errors. Their rationale is that it takes time they don't have to fix the warnings too. And I know others who treat all warnings as errors unless they have discovered that there is a compiler bug that generates spurious warnings of a particular kind (in which case that specific warning can usually be turned off). Guess which group has lower bug rates on average. I tend to fall in the latter group, having observed that with many of these things, you either fix them now or you will fix them, at greater cost, later. The second issue to consider is, "What constitutes good code, and what is necessary to produce it?" That I won't answer beyond saying, 'whatever works.' That is because it is ultimately defined by the end users' requirements. that is why we have software engineers who specialize in requirements engineering. these are bright people who translate the wish lists of non-technical users into functional and environmental requirements, that the rest of us can code to. But before we begin coding, we have QA specialists that design a variety of tests from finely focussed unit tests through integration tests to broadly focussed usability tests, ending with a suite of tests that basically confirm that the requirements defined for the product are satisfied. Standard practice in good software houses is that nothing gets added to the codebase unless the entire code base, with the new or revised code, compiles and passes the entire test suite. When new code stresses the codebase in such a way as to trigger a failure in the existing code, then when it is diagnosed and fixed, new tests are designed and added to the test suite codebase (which has the same requirement of everything building and passing all tests). of course, some do this better than others as there are reasons NASA may spend $5 per line of code while many industry players spend $0.05 per line of code. It is sheer folly for anyone to suggest that reliance on warnings and errors, even extending this to notes, ensures good code. At best, these are necessary to support development of good code, but they do not come close to being sufficient. it is trivial to find examples of C code, for computing a mean, variance and standard deviation, that is correct both WRT the ANSI standard and the compiler, and yet it is really bad code (look for single pass algorithms, and you'll find one of the most commonly recommended algorithms is also one of the worst, In terms of accuracy under some inputs, and yet an infrequently recommended algorithm is one of the best both in terms of ease of implementation, speed and accuracy). And you will still find good mathematicians defending the bad code by saying it is mathematically correct, but this is because they do not understand the consequences of finite precision arithmetic and rounding error. I would observe, as an outsider, that what CRAN is apparently doing is primarily focussed on the first issue above, but going beyond what the R interpreter does to get a better handle on a system of warnings with an extension to notes. The notes question I can understand as a pragmatic matter. If I were assigned to do the same sort of thing, I would probably do it in a similar manner, leaving some things as notes until both I and the community I serve develop a better understanding of the issues involved in the subject of the notes to the point of being better able to either have them evolve into more precisely defined warnings or die. I understand that getting many of these things can get tedious and time consuming, but in fact there is no other way for a community to analyse the issues involved and develop a good understanding of how best to handle them. But since CRAN does not appear to require requirements engineering to be completed along with a comprehensive suite of QA tests, there is no possible way they can offer any guarantees or even recommendations that any package on CRAN is good quality. From the current reaction to mere notes, I can imagine the reaction that would arise should they ever decide to do so. It is very much up to the 'consumer' to search CRAN, and evaluate each interesting package to ensure it works as advertised, and I have no doubt that some are gems while others are best avoided. Just my $0.02 ... Cheers Ted ______________________________________________ R-devel@r-project.org mailing list https://stat.ethz.ch/mailman/listinfo/r-devel
