As I've said and written over the years about this project, it is not possible
to compare features in a direct way here. The aim is to make something that
feels like "vanilla personal computing" to an end-user -- that can do "a lot"
-- and limit ourselves to 20,000 lines of code. We picked "personal computing"
for three main reasons (a) we had some experience with doing this the first
time around at PARC (in a very small amount of code), (b) it is something that
people experience everyday, so they will be able to have opinions without
trying to do a laborious point by point comparison, and (c) we would fail if we
had to reverse engineer typical renditions of this (i.e. MS or Linux) -- we
needed to do our own design to have a chance at this.
Our estimate so far is that we are getting our best results from the
consolidated redesign (folding features into each other) and then from the
POLs. We are still doing many approaches where we thought we'd have the most
problems with LOCs, namely at "the bottom".
> From: Loup Vaillant <l...@loup-vaillant.fr>
>Sent: Tuesday, February 28, 2012 2:21 AM
>Subject: Re: [fonc] Error trying to compile COLA
>Originally, the VPRI claims to be able to do a system that's 10,000
>smaller than our current bloatware. That's going from roughly 200
>million lines to 20,000. (Or, as Alan Kay puts it, from a whole library
>to a single book.) That's 4 orders of magnitude.
>From the report, I made a rough break down of the causes for code
>reduction. It seems that
>- 1 order of magnitude is gained by removing feature creep. I agree
> feature creep can be important. But I also believe most feature
> belong to a long tail, where each is needed by a minority of users.
> It does matter, but if the rest of the system is small enough,
> adding the few features you need isn't so difficult any more.
>- 1 order of magnitude is gained by mere good engineering principles.
> In Frank for instance, there is _one_ drawing system, that is used
> for everywhere. Systematic code reuse can go a long way.
> Another example is the code I work with. I routinely find
> portions whose volume I can divide by 2 merely by rewriting a couple
> of functions. I fully expect to be able to do much better if I
> could refactor the whole program. Not because I'm a rock star (I'm
> definitely not). Very far from that. Just because the code I
> maintain is sufficiently abysmal.
>- 2 orders of magnitude are gained through the use of Problem Oriented
> Languages (instead of C or C++). As examples, I can readily recall:
> + Gezira vs Cairo (÷95)
> + Ometa vs Lex+Yacc (÷75)
> + TCP-IP (÷93)
> So I think this is not exaggerated.
>Looked at it this way, it doesn't seems so impossible any more. I
>don't expect you to suddenly agree the "4 orders of magnitude" claim
>(It still defies my intuition), but you probably disagree specifically
>with one of my three points above. Possible objections I can think of
>- Features matter more than I think they do.
>- One may not expect the user to write his own features, even though
> it would be relatively simple.
>- Current systems may be not as badly written as I think they are.
>- Code reuse could be harder than I think.
>- The two orders of magnitude that seem to come from problem oriented
> languages may not come from _only_ those. It could come from the
> removal of features, as well as better engineering principles,
> meaning I'm counting some causes twice.
>> On 2/27/2012 10:08 PM, Julian Leviston wrote:
>>> Structural optimisation is not compression. Lurk more.
>> probably will drop this, as arguing about all this is likely pointless
>> and counter-productive.
>> but, is there any particular reason for why similar rules and
>> restrictions wouldn't apply?
>> (I personally suspect that similar applies to nearly all forms of
>> communication, including written and spoken natural language, and a
>> claim that some X can be expressed in Y units does seem a fair amount
>> like a compression-style claim).
>> but, anyways, here is a link to another article:
>>> On 28/02/2012, at 3:38 PM, BGB wrote:
>>>> granted, I remain a little skeptical.
>>>> I think there is a bit of a difference though between, say, a log
>>>> table, and a typical piece of software.
>>>> a log table is, essentially, almost pure redundancy, hence why it can
>>>> be regenerated on demand.
>>>> a typical application is, instead, a big pile of logic code for a
>>>> wide range of behaviors and for dealing with a wide range of special
>>>> "executable math" could very well be functionally equivalent to a
>>>> "highly compressed" program, but note in this case that one needs to
>>>> count both the size of the "compressed" program, and also the size of
>>>> the program needed to "decompress" it (so, the size of the system
>>>> would also need to account for the compiler and runtime).
>>>> although there is a fair amount of redundancy in typical program code
>>>> (logic that is often repeated, duplicated effort between programs,
>>>> ...), eliminating this redundancy would still have a bounded
>>>> reduction in total size.
>>>> increasing abstraction is likely to, again, be ultimately bounded
>>>> (and, often, abstraction differs primarily in form, rather than in
>>>> essence, from that of moving more of the system functionality into
>>>> library code).
>>>> much like with data compression, the concept commonly known as the
>>>> "Shannon limit" may well still apply (itself setting an upper limit
>>>> to how much is expressible within a given volume of code).
>>> fonc mailing list
>> fonc mailing list
>fonc mailing list
fonc mailing list