Subject: at which point is code worthy of publication?

From: Muli Ben-Yehuda <[email-masked]>
Date: Thu, 14 Nov 2002 12:14:38 +0200

I'm working for fun on a small tool called dumpmem
(http://www.mulix.org/dumpmem.html), a process memory dumper. IIRC, I
even posted a link to it here. 

I'm wondering, at which point is something like that worthy of
wide spread publication? Some people tend to publish (when I say
publish, I refer to sites like freshmeat or slashdot, not to one's
home page) everything they do, and some people tend to publish nothing
at all. I'm wondering what's the point where it becomes "acceptable"
to publish something? 

I can think of several metrics we can use to measure such a point: 

- usefullness: the more useful your project can be, the sooner you
should publish it so that people have a chance to find it. 

- effort: the more effort you put into your project, the more
"publication worthy" it becomes. 

- novelty (hack value): if your code is cool, publish it sooner rather
than later. 

What else? where do you guys think lies the cutoff point, where
publication (and self glorification) becomes the end itself, rather
then the means to an end? 
-- 
Muli Ben-Yehuda				    http://www.mulix.org/
[email-masked]:~$ sctrace strace /bin/foo  http://syscalltrack.sf.net/
Quis custodes ipsos custodiet?              http://www.mulix.org/cv.html

---

From: guy keren <[email-masked]>
Date: Thu, 14 Nov 2002 17:14:10 +0200 (IST)

> at all. I'm wondering what's the point where it becomes "acceptable"

i don't think you can set a 'clear point'. sometimes, just the idea of the 
program is enough to help somebody. sometimes - without having the fully 
working program, it is quite useless.

for example, taking something like valgrind - its useles unless it 
actually works - which means the comunity of _users_ would have nothing to 
do with it before it can actually run descent programs (at least on the 
leevl of university exercizes - so it'll help students finish homework 
earlier). on the other hand - some parts of its code could be 'leached' by 
other _programmers_ before valgrind itself fully worked.

i think you'll find that something is useful when it is 'complete' in 
_some_ manner. as you see from the examples shown here (e.g. the editor 
omer and chen were talking about) that tool did one thing well, and held a 
promise to do other things well in the future. so if someone could use the 
tool in order to complete _one_ task properly - that tool could be useful 
for them.

you can't realy know in advance if people will _actually_ use the tool - 
but you can know when it is capable of performing _one_ task fully.

if the tool can do one thing no other existing tool can do properly - its 
worthy of publishing.

if the tool can do one thing better then every other tool in the market - 
its worthy of publishing.

there is also the question of momentum - i.e. will publishing the tool now 
kill its future, or will it leave place for it to grow? this is also a 
personal matter. for example, when i started writing the lupg tutorials, i 
made up my mind that i'll first get 2-3 tutorials ready, and get the site 
designed in a way that'll allow me to grow it - because i knew that when 
_i_ start talking about something too much - i feel as if i already 
accomplished it, and then i stop working on it - so i had to wait with 
publishing it until i got at least some tutorials in it realy finished 
(and in a state that'll make them look ok). it was the first time i 
managed to publish something, and then keep working on it for a 
significant time (i published it on the end of 1998, and kept working on 
it until the end of 1999, in which i begun "stalling" - leaving it 
altogether for several month, then starting working on it again, etc - but 
not getting to publishing more tutorials). on the 'community' matter i 
failed completely - except for a error corrections coming from people, i 
didn't manage to get other people to write tutorials, or sections for 
existing tutorials. it does not mean people don't read the tutorials - i 
have lots of "users" in that sense - but i don't have co-developers ;)

> "publication worthy" it becomes. 

i think the effort issue is negligable - i've seen things into which lots 
of effort was directed - but are still not realy worthy of publishing.

> - novelty (hack value): if your code is cool, publish it sooner rather

if its just the code itself that is cool - i don't think it has any value 
published outside your own home page. if the novelty is in a very 
interesting idea about how to write code - write a document stating that, 
use the code as an example for that document, and publish this document. 
otherwise, this interesting idea about how to write code - will get lost 
in search engines land.

> then the means to an end? 

btw, one should also check the referer log of their site, in order to see 
how and why people get to it. every few month i take the last week's 
referer log for lupg and start going over the links. _most_ of them come
from searches on google (in various incarnations - mostly google.com and 
google.yahoo.com coming at a far 2nd place) where people seem to search 
for keywords regarding subject, that imply they indeed wanted to know how 
to use something (google publishes the keywords people searcherd for 
inside the URL that is the referrer to the pages that were found in the 
search). most other hits come from either 'programming resources' long 
lists, or from various college courses that thought one of the tutorials 
fits the bill for 'online documentation' for one of the exercisez, or one 
of their lectures, or so. this kind of search makes me think i managed to 
scratch the itch properly. i have another page (my 'home' page) with some 
link in it that probably completely missed the point - i was thinking 
about one thing when i wrote it, but people get to it due to searhcing (or 
via links) that come from a copletely different point of view - so from a 
'good of the public' point of view - i might better delete that page, to 
avoid missleading people ;)

hmmm. too much blubbering for one day. from the 'good of the public' point 
of view, i probably should cancel this email and let it go to the garbage. 
but i'm too selfish to do that now - i put too much effort (relative to 
how much people put into writing a single email letter) into it - that 
it'll be a waste from _my_ point of view ;)

-- 
guy

"For world domination - press 1,
 or dial 0, and please hold, for the creator." -- nob o. dy

---

From: Oleg Goldshmidt <[email-masked]>
Date: 17 Nov 2002 13:01:29 +0200

You are looking for a definition of a LPU - least publishable
unit. This is a problem that every referee working for a peer-reviewed
journal or conference faces. I've done a bit of that and it's
tough. It's tough, because it is related to another LPU - least
potential utility - of published papers.

In the context of your question, it is even tougher because you are
going to make the decision for your own stuff. You are a rare bird -
most authors won't even ask the question. Rather, the question most
authors do ask is "what is the LPU in my field so that I can publish a
string of papers rather than one, thus lengthening my publication
list?" (the so-called "salami publishing"). Some prestigious
publications discourage that, but not all.

The result in the publishing world is an avalanche of write-only
papers. I suppose the result in the software world is an avalanche of
write-only projects or revisions. This should, at some point, put a
limit to the blind application of the famous "release early, release
often" rule, good as it is.

Beyond your own criteria based on your sound common sense (I would
drop "effort" from the list, leaving "usefulness" and "novelty"), I
don't have a recipe to offer. Maybe I'll just note something that is
more pronounced in code than in science: there is a clear distinction
between "features" (my code does something new) and "bugs" (useful,
but not new). There are clearly two schools of thought here. One is
represented by everybody's favourite nemesis, Microsoft, who
practically went on record saying bug fixes are not important because
people upgrade only for new features. Thus, in their definition of an
LPU "novelty" has a high weight. You might disagree.

I would guess that Googling for "least publishable unit" will yield
some fun things to read and ponder.

-- 
Oleg Goldshmidt | [email-masked] 
========================================================
First binary search algorithm         - J. Mauchly, 1946        
First correct binary search algorithm - D.H.Lehmer, 1960