In recent years I've been unable to find anyone willing to pay me an
hourly rate for my fine work writing computer software. Apparently no
company is willing to hire anyone who has been out of work, for fear of
paying even minimum wage and getting somebody nobody else wanted and
now they know it's because they can't get any software working within a
reasonble time (hence for a reasonable amount of wages given hourly
pay). I have been offering to do trial work first, then get paid if
they like my work, but no company is willing to do even that because of
problems getting me covered under their liability insurance policy if
I'm not a legal employee yet I'm on their premises a lot. And of course
Stanford University (*SU*) was the only place that ever allowed me to
work remotely and keep track of my own hours worked, so working off
premises now is not an option. Telecommuting is a fantasy, an urban
legend.

*SU* (where I used to work before the Loma Prieta earthquake absorbed all
     their university funding for damage repair, while their president
     Donald Kennedy used governent research funds for his personal
     pleasures such as yacht and summer home so we lost all our grants as
     soon as the 1990-91 fiscal year grants expired, and a recession hit
     about the same time so IBM and other companies which had been funding
     us until then cut off their funding.)

A while back some people on the net suggested I work for a fixed-price
contract instead of an hourly wage. That way the company can tell me
what they need, and I can do all the work on my own time, and then when
I have something fully working I present it to them and they pay me
that fixed amount, and they don't have to worry I'll bill lots of hours
without getting the job done. But I never did that before, so I had no
idea how much to charge for any given program. I would like to get at
least Federal minimum wage, just as if I had an hourly job, but I have
no idea how many hours a project should cost hence no idea how much
would be a fair asking price.

During the 2005.Spring school term I took a course in distributed java.
One thing the instructor emphasized was writing up "Use Cases", and
agreeing to them with the customer, before starting any of the rest of
the design. After doing this (*UC*) for a few class homework
assignments, it occurred to me that given each Use Case specification,
I might be able to easily brainstorm with my customer (*RC*) and we
could agree to a specific list of methods needed to implement that
single Use Case in a nicely structured manner (*SP*), and I'd write up
that two-level list of use cases with methods of each. From my
experience with the homework assignments, I had an idea how long each
method took to write and unit-test (about one hour), so if I charge a
flat rate of ten dollars per method that would be fair. So putting this
all togethe, as soon as I write up the methods for each Use Case, I
could then immediately state my fixed price for each Use Case, and
hopefully the customer would be pleased at my resonable prices and
agree to the contract.

*UC* (just on my own, the instructor playing the role of "customer"
    never had time to really look at my Use Case document much less
    discuss it with me)

*RC* (a *real* customer, who actually *wanted* my software, and would
     be paying money for it, so he/she would be willing to spend the
     time necessary to make sure we were in agreement about what I'd
     be implementing)

*SP* (no method that does more than one primary task, rather a bunch of
    single-task methods and a bunch of task-controller methods that
    merely call the various single-task methods without doing any
    significant algorithm themselves)

I have found anyone anywhere around here who wants any software work
done, and all the job ads have required skills or experience I don't
have, making it a shot in the dark to send a resume to any of them, and
precluding getting any fixed-price contracts or even interviews about
such possibilities so-far.

Recently I've been working on a software project that is so large that
I couldn't keep track of it all without breaking it into modules in a
nice organized way. Each module implements all the software for
handling one kind of data, and typically provides what I call a "weak
enumeration" (*WE*), and related software (such as getting a whole list
of elements per some range specification i.e. sub-sequence, or doing
the whole process of constructing a new enumerator and getting one
element if any and discarding the enumeration within a single call,
etc.).

*WE* (instead of one method to say whether there is another element of
     the collection available later, which requires look-ahead to make
     that determination, the lookahead needing to actually calculate
     the new element in a way that changes the state of an inner
     enumeration, so the element must be cached or lost forever, and a
     second method to actually retrieve the next element of the
     collection, which was already cached during the lookahead,
     there's just a single method which returns either the next
     element if it finds any or an EOF value if it ran off the end
     before finding any new element. By the way, what I'm doing in
     many cases is having the outer enumeration be a "filter wrapper"
     or just a reference wrapper (*RW*) around the inner enumeration,
     and in some cases there are several levels of one enumeration
     acting as a filter for the next lower enumeration, and shortly
     when I'm nearly finished I'll have recursive loops in these
     enumeration wrappers)

*RW* (Whereas a "filter enumeration" simply returns the same elements
     that the inner enumeration returns, but filtering, i.e. passing
     some but nullfiling others, a reference wrapper builds a whole
     new kind of enumeration but requires some inner enumeration to
     feed it data to process to make that outer enumeration. If you
     like the word "continuation" instead of "enumeration" that's
     fine. An enumeration is nothing more than a particular kind of
     continuation, namely something that successively returns the
     elements of some collection, virtual or real, whereas a general
     continuation might return something else such as successively
     more narrow ranges around a single approximately-computed value.
     In my particular application, the dynamic nesting of reference
     wrappers will be recursive! I.e. there will be reference loops,
     where one large enumeration is defined to include a smaller
     enumeration of the same class, possibly going around the
     reference loop several times, and possibly branching in a tree
     structure of references, until the leaves of that kind of
     enumeration get small enough to use a more basic class of
     enumeration instead, finally bottoming the recursion).

Now that I've broken the program (so-far) into separate files for each
class of data being processed and the one or more enumerations dealing
with that kind of data, I can step back for a moment and see what I
have so-far, sorted by size:

8 -rw-------  1 rem  user   6591 Jul  8 18:27 2005-7-ranpri-gpsq.lisp
12 -rw-------  1 rem  user  11310 Jul  8 18:31 2005-7-ranpri-gp.lisp
14 -rw-------  1 rem  user  13319 Jul  7 18:10 2005-7-ranpri-mf2.lisp
16 -rw-------  1 rem  user  14910 Jul  7 20:43 2005-7-mbbt.lisp
16 -rw-------  1 rem  user  15653 Jul  8 18:35 2005-7-ranpri-mf1.lisp

(Those sizes include: code, per-method and per-enumeration
documentation, and unit-test rigs.)

I notice the modules range from 6591 to 15653 bytes, a factor of
2.3[7..8] (*II*), which is not very wide. After seeing this, it occurs
that I could offer a fixed price per class that I write, estimating
near the high end of 15k bytes, and if it turns out that the class
wasn't as hard as I estimated so the file didn't turn out as large as I
estimated, I could offer the customer two choices:
- Get a discount from the originally quoted price.
- Think of additional features to include in the class or in any other
  class within the same billing cycle, covered under the original
  price quote.

*II* (Hmm, as long as I keep talking about my proposals for Interval
     Arithmetic, and my proposed notation to represent known digits
     and range of unknown digits for output, I might as well use the
     same notation whenever I post an approximate real-number value in
     a newsgroup, and here (above) is my first such usage!)

So why am I posting this? Please anybody who has ever billed software
via fixed-price contracts, if you produced Java classes or Lisp modules
of approximately that size range I cited above, how much did you charge
for each such appx.-fixed-size class/module? I need your advice how
much I should state as my going price for fully working code with
unit-test and software documentation included. What's the going rate
for professional fixed-price software contracts of approximately the
size cited above.

P.S. If anybody has looked at the filenames listed above, and it
whetted your curiosity to know what big project I'm working on, just
ask and I'll tell. But if you read what I was posting about this topic
in sci.math a few weeks, you can probably guess, and I encourage to
post a followup making your guess public.