R
Robert Maas, see http://tinyurl.com/uh3t
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.
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.
