Browse thread
Estimating the size of the ocaml community
-
Yaron Minsky
-
Christopher A. Watford
-
Frédéric_Gava
-
skaller
-
Erik de Castro Lopo
- Olivier_Pérès
-
Thomas Fischbacher
-
Frédéric_Gava
-
Thomas Fischbacher
- Paul Snively
- josh
- Richard Jones
-
Jon Harrop
-
Michael Walter
-
Jon Harrop
- Damien Doligez
- Thomas Fischbacher
- Michael Walter
-
Radu Grigore
- Gerd Stolpmann
- Jon
-
Jon Harrop
- Thomas Fischbacher
- Richard Jones
-
Michael Walter
- Ville-Pertti Keinonen
- Oliver Bandel
- Basile STARYNKEVITCH
-
Thomas Fischbacher
- ronniec95@l...
- skaller
- chris.danx
-
Frédéric_Gava
-
Erik de Castro Lopo
- sejourne_kevin
- Stefano Zacchiroli
-
skaller
-
Frédéric_Gava
- Kenneth Knowles
- Michael Jeffrey Tucker
- Richard Jones
- Nicolas Cannasse
- Evan Martin
- Eric Stokes
- chris.danx
- Sylvain LE GALL
- sejourne_kevin
- Sven Luther
- Johann Spies
-
Christopher A. Watford
[
Home
]
[ Index:
by date
|
by threads
]
[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: | 2005-02-12 (18:44) |
From: | Brian Hurt <bhurt@s...> |
Subject: | Re: [Caml-list] The boon of static type checking |
On Sat, 12 Feb 2005, Thomas Fischbacher wrote: > > On Sat, 12 Feb 2005, Brian Hurt wrote: > > > And I disbeleive the "makes it easier with large programs" statement. > > It's contrary to all evidence I've seen, and all my experience. The > > complexity of a program is, I've postulated, a function of the number of > > interactions between different parts of the code. And that therefor the > > innate complexity approximately scales with the square of the number of > > lines of code- so a 10,000 line program is 100 times as complicated as a > > 1,000 line program. Brooks has evidence of this as well. > > I don't think this is true. It certainly is for spaghetti code, but isn't > it just the essence of structured programming to avoid having complexity > scale like (lines)^2? Structured programming just has a different constant factor. Also, what sort of programming you're doing also changes the constant factors. Brooks himself noticed this- that compilers seemed to be about 3 times as difficult per LOC as normal programs, and operating systems about 3 times more difficult still. Not sure if this still holds. > > There are both quite general and strong reasons why one > should expect the complexity of programs of roughly the same "style" > (whatever one has to invent to make a proper, meaningful notion out of > this) to obey a scaling law of the form > > [nontrivial interactions] ~ [lines]^N > > but not necessarily with an integer exponent. I furthermore strongly > suppose that this exponent should depend a lot on the programmer. Obviously N > 1. I'd also argue that N <= 2. But I think N is closer to 2 than to 1, i.e. N > 1.5. Assume 1,000 lines = 1 day of work (I generally toss off a thousand line program in a day)- how long does a 10,000 line program take? With N=2, the 10KLOC program takes about 100 days, or 5 man-months. You're right, that's long. With N=1.5, it takes ~31 days, or 6 weeks. This is closer. With N=1.75, it takes ~56 days (11 weeks). Assuming 5 days/week and 20 days/month. So, you're right- an N in the range of 1.5-1.75 sounds about right. Note that with N=1.5, a 100,000 program takes 1,000 man-days, or 50 man-months (4 man-years), and a 1,000,000 line program takes man centuries. The important point is the scaling is exponential, not linear. Brian