Linux -- Without Unix

Hubert Tonneau writes: "Once upon a time, Linus took GNU system, wrote a brand new kernel for it, and it was Linux. I did it just the other way round: I took Linux kernel, wrote a brand new system for it, and it is FullPliant. In very few words, Linux without Unix. This is the first system completely complying with free software's philosophy, because you can read it from the first line to the last one since all the code, including the dynamic compiler, the HTTP, FTP, SMTP, POP3, patches repository and database servers, plus the remote Web configuration tool and the strong crypto proxy, fits in a single megabyte and is compiled on the fly. The first server running FullPliant can be accessed at: [this site]." Interesting.

Comments

Re:"What's the point?"

[adolf]

From what I've been able to see so far, this -is- an attempt to make Linux better.

Remember, Linux is just a kernel. No more, no less. It's all the GNU, X and other tools that make the UNIX-like userland experience what it is, and they can all pretty much run just as well with other kernels.

There is life beyond 1972-vintage UNIX (I hope).

Re:Is UNIX its APIs?

[TheInternet]

Isn't MacOS X based on BSD? Raphsody was Mach, yes?

Both Mac OS X Server -- aka "Rhapsody" -- and Mac OS X public beta are based on Mach. MOSXS is based on Mach 2.5, MOSXPB is based on Mach 3.0. Both also have a 4.4BSD "personality." BSD is used for networking (BSD Sockets), process model, kernel APIs, POSIX threads, as well as the BSD command line tools.

- Scott

------
Scott Stevenson

Re:How is that INTERESTING?

[commandant]

Funny, I thought he was focusing his creative efforts on Linux development. My God, even in the post itself, he says, "Linux without Unix."

What he's doing is making a new nest for Linux to rest in. I don't see why you have a problem with that. If you don't like FullPliant, don't use it. But don't knock it, and especially don't knock it when you don't know what you're saying.

A new year calls for a new signature.

Is UNIX its APIs?

[peter303]

There have been several attempts to radically rewrite UNIX internals, yet appear to be UNIX on the outside. The most prominent I am aware of is CMU-Mach which most prominent commercial incarnation was NextOS and Mac-OS X (with one of the original grad students now running Apple's R&D). NT at one time claimed to want do this via a VMS-like internals. (POSIX API emulation was a government purchase requirement at one time.)

Re:intresting, but...

[Traser]

well, linux is pretty cool man, but i grew up with DOS, gee, i wouldn't want to try something different...

The difference is I do use linux, and I do enjoy, no , it isn't the friendly DOS I grew up with, but I rather enjoy it. This Pliant think intrigues me, and I think I'll give it a try. Innovation and trying things that haven't been done before bring out new and interesting products. It is vital to all research and advancement that pure research be done for it's own sake - because it is cool.

Re:what does this accomplish?

[Muggins the Mad]

> I have to admit, this just doesn't make sense.
> All this hard work I just can't see it going anywhere, its like dumping all the work (good or bad) and essentially starting over.

Just like Linus did by writing the Linux kernel instead of trying to improve the Minix kernel, you mean?

> I just cannot see how this can be done without huge backing from someone like Sun, Microsoft, or Apple.

I have difficulty seeing how this *could* be done with backing from a huge corporation.

A bunch of good programmers working together on something they think is cool can produce much better work than a bunch of programmers being continually ordered around by a marketting department.

GNU + Linux isn't the be all and end all of operating system design. None of the systems we have today are. We need people to continually try new ideas and come up with unfamiliar things.

- Muggins

Re:Isn't this like NeXT?

[TheInternet]

Isn't this how the NeXT system started, with a new set of cool tools wrapped around a BSD kernel?

I don't think NeXT ever used a BSD kernel. At least in the later implementations, it was using Mach.

- Scott
------
Scott Stevenson

Re:Don't Point, it's not polite

[fm6]

[side note: Linus might've been able to take a shortcut if he had used the Mach kernel as a springboard like OSF and Hurd eventually did!]

A side effect of this discussion is that I read the HURD docs more carefully than I have in the past. I get the impression that Stallman has a long-standing infatuation with the Mach kernel and has always wanted to make it the heart of his GNU OS. Part of the long delay in developing the Hurd seems to have been caused by the long struggle to get the Mach kernel open-sourced.

There may also have been economic factors. Many of the GNU tools had their development sponsored by various hardware companies such as Sun and SGI. I would speculate (and I emphasize speculate) that these hardware companies didn't see open-source editors and compilers as competition, and were indeed having trouble developing them internally. But even hardware companies consider OS kernels to be a basic product, and are not about to subsidize a "free" version of Mach!

If anything, the comment could have been re-phrased better as Linus+Minix+(gnu tools)=Linux, but (apologies to Andy Tannebaum) I don't believe Linus ever used any of the minix source on his development path, since he says just that in the initial announcement of his plans.

No, the Linux debt ot Minix is pretty minimal. For one thing, Minix has a microkernel architecture, which LT considers overrated. Second, at the time Minix was still a commercial product with a closed-source license -- part of LT's motivation was that he didn't have the pocket money to buy it!

__________________

First system complying with WHAT?

[Tony Shepps]

What philosophy, is it, exactly, that requires everything to be compiled on the fly?

Was it Kant that talked about interpreted code. Now, I believe Descartes hypothesized a proof for God based on the idea that self-modifying programs could not be construed as a perfect model of any single thing. And the Chinese talk about the severing of the mind-body relationship through the long-term contemplation of object orientation. And Adm. Grace Hopper lectured on the idea that through debugging it could be determined that the nature of man can always be proven flawed.
--

Extensible Languages

[fm6]

I think some of his stated goals are worthwhile: I consider making languages truly extensible a worthwhile goal, for example, and one which very few languages today even come close to.

Even though you only meant it as an example, I'd like to discuss this point further. Extensible languages have been around as long as I can remember, but they never seem to have caught on. Perhaps people just don't see any utility in them?

Now that I think of it, C++ might count as an extensible language, since you're allowed to overload the built-in operators. But C++'s detractors consider this a prime example of the language's unnecessary complexity. Perhaps the same can be said for extensibility in general?

__________________

Re:Extensible Languages

[alienmole]

If the following lacks coherence or is overly long and rambling, that's 'coz it's 3am and I don't feel like editing it into an ironclad position paper.

Tell me what you consider an extensible language and I'll tell you why I don't think it's extensible enough.

C++ isn't a good example to use, since the level from which it starts is such that no matter how much you extend it, you can't get away from its basic closeness-to-the-machine. That's its strength, when you need it, but you don't always need it. (I'm a good C++ programmer and have developed commercial products with it, so I do have some basis for saying this.)

The criticism of C++ operator overloading is a separate discussion, really, and you have to examine the specifics of the criticism. I don't buy the "it's too powerful so it's confusing/dangerous" kind of argument - that's merely an argument against letting certain programmers loose with it. If one is against operator overloading in general, then you'd have to be against it in other languages like Haskell or even Smalltalk (where operators have names instead of symbols), and I haven't really heard that kind of general criticism. I think the problem a lot of people have with C++ is that it's just plain big and confusing - it has a steep learning curve to reach full competence, and features like operator overloading may appear somewhat "tacked-on". So I don't think the C++ example is really relevant in a discussion of extensibility in programming languages, since I see C++ as having special constraints which aren't faced by higher-level but lower-performing languages.

In general, I think operator overloading is an essential extensibility feature and should probably have its name changed to make it sound less like some kind of extreme measure. In any language in which you can define new data types, you ought to be able to define the operations on those types, and have the language be aware of the relationship between the types and operations. If you can't at least do that, then you're back to plain old procedural programming in FORTRAN/Pascal-original/C.

But extensibility is not just being able to define new classes of object, and the operations on those objects, although that kind of thing is a start.

There are many areas in which extensibility is conceivable and potentially desirable. One that has not been well-addressed is syntax extensibility. The C/C++ preprocessor is one of the most widely-used programming features in existence - take a look at any source code for Linux or GNU and this is quite obvious. However, there are well known problems with this mechanism, and some of those problems significantly limit the potential uses of preprocessor-like features. C-like preprocessors support extensions that don't conform to the language's syntax rules and don't really follow any grammatical-style rules of their own, for example. There have been some attempts at coming up with syntax extensibility which doesn't suffer from this problem, notably in Scheme; but in Scheme, the feature is still constrained by the basic everything-is-a-function-call design of the language.

It can be argued that syntax extensibility isn't necessary or desirable, but I think it's usually an argument from a position of never having had a good example of it. An interesting example of syntax extensibility could be found in the old Clipper database language, which had a very powerful preprocessor that many third-party companies used to create custom command sets, more powerful than the kind of thing that can be done in with C-style preprocessors. This was a very popular feature. However, that preprocessor still suffered from the same problems as the C/C++ preprocessor.

I would be willing to bet large sums of money that if a competent language became available which had useful and theoretically sound syntax extensibility capability, users would go crazy for it. For a comparison in a slightly different area, look at what's happening with XML - everyone and his dog is designing new mini-languages using XML. Some might criticize this or be unnerved by it, but it's filling a need, and even if many examples of XML-based languages are unwise or poorly designed, many are very useful.

Then there's the question of the limitations of existing extensibility features. For example, object-oriented languages which only provide single inheritance are self-limiting in terms of the designs that can be practically implemented in them. I'm not suggesting that traditional multiple inheritance is an essential feature in those environments: I think the problem is that both approaches are wrong. There's more of a future in the separation of interface and implementation required by environments like CORBA and COM, although CORBA also came from an objects-have-a-single-interface direction. From a type-theory perspective, it's obvious that data types can have more than a single interface, but it's also obvious that this doesn't mean that they have to share implementations. So you need the ability to define multiple interfaces on a type or class, and ideally the ability to reuse implementations somewhat independently. The only languages I'm aware of that let you do anything even remotely close to this are some of the functional languages, like Haskell. Interestingly, Java came close but didn't quite make it: it supports classes with multiple interfaces, but the semantics of combining interfaces is slightly broken, and the ability to reuse interface implementations is virtually nonexistent.

So I'm suggesting that many languages with alleged extensibility features actually have serious Achille's heels which limit the usefulness of those features.

Some might say that languages like Smalltalk are extensible. Superficially, that may seem true. But in a sense, they're the opposite of extensible: everything is an object and all operations are message sends, and that's all the compiler understands, syntactically. This makes it trivial to write compilers for the language, but doesn't make the language easier for ordinary humans to write and read. You can add object classes, but you can't build it up beyond the level it was designed to operate at. In this sense, I see languages like Smalltalk, and to a lesser extent, Scheme, as severely limited, rather than extensible. Some might consider this a perverse perspective, but it comes from experience and I can provide real world examples of problems that are difficult to solve in these languages, that can be handled by something as simple as, again, the C preprocessor.

Some of this is just the inevitable mismatch between theoretically-based languages, arising from various mathematical, logical, or computing science formalisms, which tend to be aimed at highly intelligent users in the sciences; and the needs of a broader mass market which usually has far more mundane concerns, including many relating to apparently extraneous issues like deployment, portability, configuration management etc.

The bottom line is that I think we're still in the most incredibly early stages of computer language development. That's probably because designing a really good computer language is an extraordinarily difficult task, and changing people's programming habits is even more difficult. But progress does happen, slowly. Languages like Java don't represent the state of the art in theoretical language design, but they do represent the slow trickling down of powerful theoretical features into languages that are in widespread use. But standard Java doesn't even support something as basic as first class functions or closures, so we have a long way to go.

Happy New Year!

Re:Programmers and the Rest of the World (TM)

[RomulusNR]

Accept, at least, this observation: that those who program computers make computers do what they want, and those who don't program computers do what the computers want them to do.

Certainly people should opt to be in the former group, in terms of the ends.

Re:Lisp a logical language?

[sugarescent]

You guessed wrong, about as completely opposite as it gets. Function arity refers to typing a function by how many args it takes, which is useful when the function is overloaded (which LISP doesn't support, either).

If functions do different things, then name them different things. And as a reply already noted, the object system in Lisp (CLOS) supports overloading of methods (check out defmethod)

Wrong again. Think "currying".

Fine. Lisp doesn't have syntax for it. But it can be done. Easily, in fact.

Do me a favor, learn what I'm talking about before responding to it. Learn a little about Haskell or ocaml first perhaps? I'm really too tired to flame, but you would deserve it otherwise.

Sorry if I had questions or appeared ignorant. It happens when people are learning or when confronted with unfamiliar language (partial evaluation == currying? whatever!). Lisp has list comprehensions and has for some time. Check the SERIES package if you want to see what I mean. Functional programming in Lisp! Amazing!

-sugarescent

Comment removed

[account_deleted]

Comment removed based on user account deletion

No better

[cd_Csc]

Looks like it's susceptible to the Slashdot Effect... but this time I wouldn't expect any mirrors.

Re:Why not GNU Pliant?

[Datafage]

Maybe he wants to maintain independence, retain copyright of work he created, and other such frivolties? With all the complaints about Microsoft absorbing everything, why should the FSF take control of all things Linux? I mean, the Microsoft absorbees get lots of support for their product, if it was good enough, and a boost from the brand recognition. This is the same thing.

-----------------------

Another location

[pc486]

Here is another offical homepage (it's just not up updated to the last second): http://pliant.cx/

Re:Another location

[Mr. Jaggers]

Actually that is simply release 44, running at pliant.cx; there is really only one official homepage.
Release 53 (the current version) is what Hubert is presenting at the location in the original story.

They are both at pliant.cx.

/bin/pliant ?

[Drone-X]

A warning for those that are yet to install it.. and that are as careless as me.

This thing installs in prefix "/". There are two alternative installation directories being /usr/local and $HOME.

Just untar the file to prefix/pliant (where prefix is /, /usr/local or $HOME) and then follow the instructions.

Re:You beat me to it...

[brunes69]

Imagine having all programs on your system store all their configuration information in one consistent place - or just one place for systemwide stuff and one place for each user's local configs. Imagine if all the configuration files had the same format.

I.E. The Windows95/98 Registry???

Score: -1, Troll

---There is no spoon....---

Re:VB Generates real code

[weloytty]

<<Your post, for me, damns VB - was it intended to? >>

As I said in the original post,

>>Now, we can argue that the code does too much for you, (or to you, depending on how you feel), but it IS real code.<<

And the code I ran in the debugger had all optimizations disabled. Optimized, the code looks like:

Form1::AddItUp:
00401A62 55 push ebp
00401A63 8BEC mov ebp,esp
00401A65 51 push ecx
00401A66 51 push ecx
00401A67 68C6104000 push offset ___vbaExceptHandler
00401A6C 64A100000000 mov eax,fs:[00000000]
00401A72 50 push eax
00401A73 64892500000000 mov dword ptr fs:[0],esp
00401A7A 83EC28 sub esp,28h
00401A7D 53 push ebx
00401A7E 56 push esi
00401A7F 57 push edi
00401A80 8965F8 mov dword ptr [ebp-8],esp
00401A83 C745FCB0104000 mov dword ptr [ebp-4],offset __imp___CIexp+3Ch
00401A8A 8B450C mov eax,dword ptr [AddItUp]
00401A8D 8365E000 and dword ptr [AddItUp],0
00401A91 8D55CC lea edx,[unnamed_var1]
00401A94 8D4DE0 lea ecx,[AddItUp]
00401A97 832000 and dword ptr [eax],0
00401A9A 66C745D41900 mov word ptr [ebp-2Ch],19h
00401AA0 C745CC02000000 mov dword ptr [unnamed_var1],2
00401AA7 E8A4F6FFFF call ___vbaVarMove
00401AAC 68BD1A4000 push offset $L61
00401AB1 EB09 jmp $L56
$L35:
00401AB3 8D4DE0 lea ecx,[AddItUp]
00401AB6 E89BF6FFFF call @__vbaFreeVar
00401ABB C3 ret
$L56:
00401ABC C3 ret
$L61:
00401ABD 8B7D0C mov edi,dword ptr [AddItUp]
00401AC0 8D75E0 lea esi,[AddItUp]
00401AC3 A5 movs dword ptr [edi],dword ptr [esi]
00401AC4 A5 movs dword ptr [edi],dword ptr [esi]
00401AC5 8B4DF0 mov ecx,dword ptr [ebp-10h]
00401AC8 33C0 xor eax,eax
00401ACA A5 movs dword ptr [edi],dword ptr [esi]
00401ACB A5 movs dword ptr [edi],dword ptr [esi]
00401ACC 5F pop edi
00401ACD 5E pop esi
00401ACE 64890D00000000 mov dword ptr fs:[0],ecx
00401AD5 5B pop ebx
00401AD6 C9 leave
00401AD7 C20800 ret 8

The only extra things I see are the installation of an exception handler and setting up the return. The size of all of the 'junk' that VB puts in there looks really big...if this were a real function, the relative size of the stuff that VB does for you should shrink to (near) insignifigance. Look at this C++ code:

And MFC code that does

int AddItUp(){

int i;

TRY{
i = 10 + 15;
}CATCH(CException ,ex){
//nada
}
END_CATCH
return i;
}
looks like this:

44: int AddItUp(){
00401530 55 push ebp
00401531 8B EC mov ebp,esp
00401533 6A FF push 0FFh
00401535 68 89 2A 40 00 push offset __ehhandler$?AddItUp@@YAHXZ (00402a89)
0040153A 64 A1 00 00 00 00 mov eax,fs:[00000000]
00401540 50 push eax
00401541 64 89 25 00 00 00 00 mov dword ptr fs:[0],esp
00401548 51 push ecx
00401549 83 EC 50 sub esp,50h
0040154C 53 push ebx
0040154D 56 push esi
0040154E 57 push edi
0040154F 89 65 F0 mov dword ptr [ebp-10h],esp
00401552 8D 7D A0 lea edi,[ebp-60h]
00401555 B9 14 00 00 00 mov ecx,14h
0040155A B8 CC CC CC CC mov eax,0CCCCCCCCh
0040155F F3 AB rep stos dword ptr [edi]
00401561 8D 4D E4 lea ecx,[_afxExceptionLink]
00401564 E8 39 01 00 00 call AFX_EXCEPTION_LINK::AFX_EXCEPTION_LINK (004016a2)
00401569 C7 45 FC 00 00 00 00 mov dword ptr [ebp-4],0
00401570 C6 45 FC 01 mov byte ptr [ebp-4],1
00401574 C7 45 EC 19 00 00 00 mov dword ptr [ebp-14h],19h
0040157B EB 3E jmp __tryend$?AddItUp@@YAHXZ$1 (004015bb)
0040157D A1 2C 62 41 00 mov eax,[__imp_?classCException@CException@@2UCRuntime Class@@B
00401582 50 push eax
00401583 8B 4D E0 mov ecx,dword ptr [ex]
00401586 E8 11 01 00 00 call CObject::IsKindOf (0040169c)
0040158B 85 C0 test eax,eax
0040158D 75 1A jne __catch$?AddItUp@@YAHXZ$0+2Ch (004015a9)
0040158F 0F BF 0D 78 55 41 00 movsx ecx,word ptr [__LINE__Var (00415578)]
00401596 83 C1 06 add ecx,6
00401599 51 push ecx
0040159A 68 30 55 41 00 push offset THIS_FILE (00415530)
0040159F E8 F2 00 00 00 call AfxAssertFailedLine (00401696)
004015A4 85 C0 test eax,eax
004015A6 74 01 je __catch$?AddItUp@@YAHXZ$0+2Ch (004015a9)
004015A8 CC int 3
004015A9 33 D2 xor edx,edx
004015AB 85 D2 test edx,edx
004015AD 75 CE jne __catch$?AddItUp@@YAHXZ$0 (0040157d)
004015AF 8B 45 E0 mov eax,dword ptr [ex]
004015B2 89 45 E8 mov dword ptr [ebp-18h],eax
004015B5 B8 BB 15 40 00 mov eax,offset __tryend$?AddItUp@@YAHXZ$1 (004015bb)
004015BA C3 ret
004015BB C7 45 FC FF FF FF FF mov dword ptr [ebp-4],0FFFFFFFFh
004015C2 8D 4D E4 lea ecx,[_afxExceptionLink]
004015C5 E8 3B FA FF FF call @ILT+0(AFX_EXCEPTION_LINK::~AFX_EXCEPTION_LINK) (00401005)
004015CA 8B 45 EC mov eax,dword ptr [ebp-14h]
004015CD 8B 4D F4 mov ecx,dword ptr [ebp-0Ch]
004015D0 64 89 0D 00 00 00 00 mov dword ptr fs:[0],ecx
004015D7 5F pop edi
004015D8 5E pop esi
004015D9 5B pop ebx
004015DA 83 C4 60 add esp,60h
004015DD 3B EC cmp ebp,esp
004015DF E8 CA 00 00 00 call _chkesp (004016ae)
004015E4 8B E5 mov esp,ebp
004015E6 5D pop ebp
004015E7 C3 ret

So no, I guess I dont think too much bad about VB.

Re:You beat me to it...

[mpe]

What I would propose is just a standard place for each app to put its config files, and a standard format for the files.

You can only take "standard format" so far, since different apps need different configuration. You'd probably have to stop at a common syntax and basic structure.

I would want text-only config files so that the could be hand-hacked.

With anything other than the simplist configurations GUI tools become hopless anyway. Anyway isn't the whole point that the global configurations should explicitally non alterable by end users.

for example /config/WindowMaker/0.62.1/configfile This hierarchy could be duplicated in each user's home directory for their local config if there is any - /home/eric/config/.....

note that a per user config file need not have the same structure as a global config file. Typically there are things which only make sense to alter locally. Also it would be very useful to have a global config file which does things conditionally based on user/group membership (including ignoring parts or the entire contents of any per user config.)

Re:We already have it

[mpe]

you can make changes to the windows registry from the command line. or by editing a text file and naming it *.reg (file associated with the registry)

Except that .reg files can only add keys to the registry (or change the values of existing ones.) Or does Win2000 now come with a version of regedit which can use a .reg file to remove registry keys?

Re:A small question

[William Tanksley]

I'm not sure what you mean by "new low level functions", but I'm certain Forth can compile them :-). Forth has the ability to compile compiler and normal words (IMMEDIATE versus non-IMMEDIATE), and words can be written in Forth or CODE (assembler).

Most of the OSes written in Forth are called "Forth", and behave very much like this. I like the looks of this one, of course.

-Billy

Re:Lisp a logical language?

[scrytch]

> LISP is a functional language

That's debateable. LISP has no typing, function arity, partial evaluation, composition, list comprehension, or even function predicates (not sure if that's the right name, it's where it only applies the function if the predicate matches).

Sure you can do all of those in lisp, but you have to do it by hand. I could do the same in python, java, or even C, if I were wont to do such grunt work by hand.

I'd suggest that ocaml or haskell are closer to being functional languages than lisp. lisp to me feels like pascal with prefix syntax.

--

Re:Don't Point, it's not polite

[alienmole]

Is anyone going to comment on FullPliant's unique features, or is everybody stuck on Religious Flamewar mode?

I think the most interesting thing about FullPliant is the whole concept of taking the Linux kernel by itself and using it to build a system free of all the grodiness of the GNU utilities, X, etc. If this helps expand people's imaginations about possible uses for the best GPL'd OS in existence, that's great. And that way, RMS would finally have to stop complaining that it should really be called GNU/Linux! ;^)

But I don't see the actual FullPliant implementation as much more than a curiosity. The language seems to embody many of the author's personal preferences and prejudices ("inheritance leads to too clever and sophisticated programs"), and the end result seems predictably mediocre. I think some of his stated goals are worthwhile: I consider making languages truly extensible a worthwhile goal, for example, and one which very few languages today even come close to.

But unfortunately, even if FullPliant succeeds in achieving one or other of its goals, the fact that it is such a complete package, right down to a page definition language of dubious value, is likely to inhibit its actual use. I think the author would do better to focus on pushing Pliant as a language with certain unique features, than somewhat Java-like, as a "platform". The whole "Linux without Unix" slant of this /. article is a case in point: no-one's even talking about the language or compiler technology, and what value it may have.

The platform-like stuff could be included as "sample code". It all reminds me a little of things like Pike+Roxen, which undoubtedly could also be implemented on top of a naked Linux kernel to provide a server that, in general, would be pretty useless in real life...

Tony Shepps, meet Gregory Chaitin...

[alienmole]

Read a bit of Gregory Chaitin's book, The Unknowable (the linked site seems to contain the full text), and you will find some mathematical/philosophical assertions, backed up by LISP code, that aren't so far from the kinds of things you suggest. Gödel's Incompleteness Theorem and Turing's proof of the unsolvability of the Halting Problem, are allegedly proved using LISP programs. And of course, programs like this tend to require that the language be able to evaluate/compile expressions at runtime, so perhaps the original claim isn't so off-base! ;)

VB Generates real code

[weloytty]

>>how many CPU instructions does function x in VB (or java or eiffel or Smalltalk or perl ... ) use ? What does the program look like when converted to assembly ? This is the kind of question that one can often answer very quickly in C++ or C code, and is impossible to answer with the other languages. <<

Ummmmm, actually, saying that you cant get at the disasm of VB code isnt true. You can compile VB5+ to native code, include debug info, and fire it up in your favorite debugger. Its regular old win32 code.

(It is also my favorite way to debug MTS components that die--just create a dump of the process, load it up in WinDBG and have at it <g>)
For example,

Private Function AddItUp()

Dim x As Integer
x = 10 + 15
AddItUp = x

End Function

Translates to:

Form1::AddItUp:
00401A6F 55 push ebp
00401A70 8BEC mov ebp,esp
00401A72 51 push ecx
00401A73 51 push ecx
00401A74 68C6104000 push offset ___vbaExceptHandler
00401A79 64A100000000 mov eax,fs:[00000000]
00401A7F 50 push eax
00401A80 64892500000000 mov dword ptr fs:[0],esp
00401A87 6A28 push 28h
00401A89 58 pop eax
00401A8A E831F6FFFF call VB@TEXT
00401A8F 53 push ebx
00401A90 56 push esi
00401A91 57 push edi
00401A92 8965F8 mov dword ptr [ebp-8],esp
00401A95 C745FCB0104000 mov dword ptr [ebp-4],offset __imp___CIexp+3Ch
00401A9C 8B450C mov eax,dword ptr [AddItUp]
00401A9F 832000 and dword ptr [eax],0
00401AA2 66C745DC1900 mov word ptr [x],19h
00401AA8 668B45DC mov ax,word ptr [x]
00401AAC 668945D4 mov word ptr [ebp-2Ch],ax
00401AB0 C745CC02000000 mov dword ptr [unnamed_var1],2
00401AB7 8D55CC lea edx,[unnamed_var1]
00401ABA 8D4DE0 lea ecx,[AddItUp]
00401ABD E88EF6FFFF call @__vbaVarMove
00401AC2 68D31A4000 push offset $L62
00401AC7 EB09 jmp $L57
$L35:
00401AC9 8D4DE0 lea ecx,[AddItUp]
00401ACC E885F6FFFF call @__vbaFreeVar
00401AD1 C3 ret
$L57:
00401AD2 C3 ret
$L62:
00401AD3 8D75E0 lea esi,[AddItUp]
00401AD6 8B7D0C mov edi,dword ptr [AddItUp]
00401AD9 A5 movs dword ptr [edi],dword ptr [esi]
00401ADA A5 movs dword ptr [edi],dword ptr [esi]
00401ADB A5 movs dword ptr [edi],dword ptr [esi]
00401ADC A5 movs dword ptr [edi],dword ptr [esi]
00401ADD 33C0 xor eax,eax
00401ADF 8B4DF0 mov ecx,dword ptr [ebp-10h]
00401AE2 64890D00000000 mov dword ptr fs:[0],ecx
00401AE9 5F pop edi
00401AEA 5E pop esi
00401AEB 5B pop ebx
00401AEC C9 leave
00401AED C20800 ret 8

Now, we can argue that the code does too much for you, (or to you, depending on how you feel), but it IS real code.

Re:VB Generates real code

[weloytty]

Yeah, but we arent comparing apples to apples. Does your code have the try/catch blocks in it?

Without the try/catch, optimized for size, VC looks like:

004010C3 6A 19 push 19h
004010C5 58 pop eax
004010C6 C3 ret

<g>

Cant get much smaller than that :-)

Oh no, not another one!

[zxSpectrum]

They claim they are trying to make you a programmer. This page describes their .page-format, as an alternative to html.

Pity they haven't understood what (proper) html is about. They've gone and created this visual, contextless (or meaningless, if you will) markup-language, which is converted to equally rotten html. They also claim for "dynamic" pages, which, as I see it is a rather poor excuse for limited, and limiting server-side scripting.

From my point of view, they've tried reinvent the wheel as a square. For instance, from theirwebsite

Pliant programs always run in the compiler itself, which compiles on the fly. Thus, a program can ask to compile another piece of code at any time (equivalent to the 'eval' instruction in many interpreters), or free some compiled code (a compile function is a data). All of this gives great flexibility.

Ain't this just a poor way of saying "A Just-in-Time-compiler is about the only thing we'll let you work with"? Just my NKr. 02

Re:Oh no, not another one!

[warpeightbot]

> They claim they are trying to make you a programmer.

Won't work. Not everyone wants to be a priest. Not everyone is brave enough to talk to the Goddess all by herself. Some people just want to linger at the edge of the Circle, or lean back in the pews, and let someone else do all the dirty work. They just want things to work without them having to think too much. As long as they can doubleclicky on the thingamabob and the spinner goes spinny and brings them the latest edition of Dilbert, everything's cool, everything's fine. They'd have no idea what to do with a hash prompt.

Now, this is not to say that a properly set up Be or *BSD or even (gasp) Linux won't do this just as well if not better than WinDoze. As long as they have someone like me to call when a power-out causes fsck to hang on boot-up.... but then how many folks actually install their own WinDoze?

Frankly, I think if any of the "new" OS's have a chance, other than the ones I mentioned above, it's Plan 9. If for no other reason than the rather serious amount of propellorhead power behind it... after all, we're talking about the same folks who dreamed up Unix in the first place, and the transistor before it. Never, ever underestimate the raw power of Ma Bell.

--
Open standards. Open source. Open minds.
The command line is the front line.

"How is it interesting?"

[evanbd]

OK moderators, forgive me, but it is a VALID question. I don't really know enough about what he's done to know more than it looks like he rewrote everything really small and compact and (presumably) efficient. That's cool. Now what? The site seems slashdotted, so would someone mind telling me what's great here? I just don't think enough of us understand well wnough what was done to see how it's cool in detail greater than what I said above. So please, enlighten us. Thanks.

Re:You beat me to it...

[Dr. Evil]

I've been toying about with the idea of a standard API to open, read and write configuration files. Then people could use the architecture most suitable for thier particular situation, be it a memory resident registry-like system, or be it configuration files scattered all over the drive. The only difference is that people could make choices concerning performance/volatility tradeoffs.

A simple example of how this could be done would be something akin to a symbolic link which is really a dynamic file. You can open it, read from it, and hopefully even write to it in a limited capacity. The libary would translate these actions to and from the desired configuration changes... perhaps smiting you for syntax errors in the file layout (send the program an error that the file is read-only or something)

A bit like /proc only scattered all over the drive. They look like a bunch of text files, you can write to them, but they're not what they appear.

More than just an OS

[electricmonk]

It appears to also be a programming language. It's pretty interesting, too, as it proclaims to be somewhere between the efficiency of C (which he likens to machine logic) and the ease of use of Lisp (which he likens to human logic). You can find the details at the philosophy section of his site.

Re:eh?

[Phroggy]

Noooo, not the Windows Registry. More like the Preferences folder on a Macintosh. If one app's settings get corrupt, you just trash that file and the program rebuilds it from defaults automatically. With Windows, you can corrupt the entire database, and there's really no way to fix it (you can restore a backup, but not fix it).

--

Re:Interesting, here are similar technologies

[HiThere]

If it's similar to Self, I'm interested. That was a really promising project. Too bad it seems to be dead.

Caution: Now approaching the (technological) singularity.

Re:A small question

[HiThere]

I don't dis VB because it's slow. I dis VB because it's stupid, silly, inconsistent, buggy, irrational, ridgid (in foolish places), floppy (in other foolish places), etc. Slow is the least of it's problems. In fact I think it's faster than Java (faint praise) on Win95 + Office 2000.

I dis it because I have to use it and I'd rather never see it again.

Caution: Now approaching the (technological) singularity.

Re:Lisp a logical language?

[sugarescent]

That's debateable. LISP has no typing, function arity, partial evaluation, composition, list comprehension, or even function predicates (not sure if that's the right name, it's where it only applies the function if the predicate matches).

I'm not sure what you mean by no typing. Perhaps you haven't looked at the types and classes section of the Common Lips HyperSpec. Maybe you also forgot how to declare the types of arguments your function takes.

I'm guessing by "function arity" you mean functions taking arbitrary numbers of arguments. Sorry. Common Lisp has those (so does Scheme, as a matter of fact).

Composition of functions? Lisp has had those for a long time. So what if you have to write the function to do it yourself? It's not that hard (think two lines or so).

Partial evaluation == lazy evaluation? Can be done. A macro and a function -- less than five lines total.

Function predicates? Where you check the arguments of a function before executing it? Not that hard and can even be integrated with the type-checking (see above).

I don't know what you mean by list comprehension, but I'm willing to bet that it's not hard.

Functional languages are somewhat open to argument. If you're talking about pure functional languages, then no, Lisp is not a functional language. However, I would argue that much of the research on functional languages and the techniques used in their compilation have come from Lisp. And if you're willing to fudge a little bit, Lisp looks a lot like a functional language.

All the languages that you mentioned are Turing-complete, so you can do anything in one language that you can do in another. It's my opinion that you can do it all easier in Lisp (what's the deal with the syntax of OCaml or Haskell? very very ugly! no syntactic abstraction like Lisp).

If you think Lisp is just Pascal, then you haven't looked at Lisp very closely. Try "On Lisp" by Paul Graham or "The Art of the Metaobject Protocol" by Kiczales et al to see a few things that Lisp is capable of doing.

-sugarescent

Language barrier

[Goonie]

Unfortunately, the thing is /.'ed, so I can't read the documentation myself, but judging from the submission the guy's English isn't exactly great. He might be claiming that Pliant is the best compromise between flexibility and execution speed he's seen. It might well be the best language he's ever seen to meet *his* particular requirements. This is a fairly common belief amongst language designers, and it's usually true ;)

The Mercury programming language is another interesting example of a programming language. The Mercury group's goals were to build a logic programming language suitable for large conventional programming projects. Therefore, they required it to have execution speed comparable to conventional imperative language, strong typing, full support for I/O without going outside the logical framework, a module system, amongst others. Not surprisingly, they claim that their project so far supports *their* goals better than any other language, and they are probably right too!

It's difficult, but not impossible, to design languages that meet your requirements better than existing ones. Languages become widely used when your goals match the needs of a sufficiently large group of programmers significantly better than their current language.

Re:A small question

[localroger]

Firstly:

Starting with 4.0, VB isn't interpreted any more. It is compiled, and while it isn't as well optimized as C it is pretty durn fast.

Secondly:

The situation with Pliant is a little more complex. It is a lot closer to Forth than a P-coded language like VB 3.0 and back, QBasic, or old-style Pascal. It has two kinds of module, both of which it seems you can compile yourself; the low level modules are compiled with an optimizing compiler that will, when it is finished, make them every bit as wicked fast as C. These modules actually become part of the language for future use purposes. (Forth? Anybody else reminded of Forth here? Except you couldn't compile new low-level functions for Forth, and you apparently can for Pliant.) Things at high levels of abstraction are built with these low-level modules, which doesn't cost much in performance because such code usually isn't very optimized anyway. The version 44 site isn't /.ed and has plenty of info on the language's design philosophy.

As I posted elsewhere I find this very interesting, and will be waiting with bated breath for the server to clear. Oh, and FYI it hasn't crashed, though it's very slow. Another monument to the solid design of the Linux kernel, I'd guess.

Don't Point, it's not polite

[fm6]

I'm sure Linus Torvalds probably heard some comments like this when he was originally working on building the first Linux kernel.

What's your point? That LT explained himself, and now nobody ever has to explain themselves ever again?

Anyway, there's a big fallacy in this whole discussion. Everybody seems to think that LT woke up one day and said "Eureka! (My kernel work) + (GNU Project) = A NEW OS !" That's not what happened. For one thing, GNU always had their own kernel (althougth they've taken their sweet time finishing it!). For another thing, LT was never a big fan of most of the GNU software (in this article he expresses admiration for GCC, but attitudes ranging from indifference to absolute disgust with everything else).

The simple fact is that LT wrote a simple POSIX-compliant kernel for his own private purposes -- mainly self-education. It was the viral marketing that he unintentionally started by giving the source to his friends that established Linux+GNU as a new OS. I once heard him say he was more shocked by the 100th copy of Linux than the 1 millionth!

That being said, it might well be interesting and useful to create a new "OS" based on the Linux kernel. "Completely complying with free software's philosophy" strikes me as a rather silly motivation, but Tonneau does seem to have done some interesting work that bears further discussion. Is anyone going to comment on FullPliant's unique features, or is everybody stuck on Religious Flamewar mode?

__________________

Re:what does this accomplish?

[Squid]

GNU + Linux isn't the be all and end all of operating system design. None of the systems we have today are. We need people to continually try new ideas and come up with unfamiliar things.

Heresy! Burn him at the stake!

Interesting, here are similar technologies

[JordanH]

Without trying to detract from Pliant, this reminds me a lot of the Self project.

Interesting links on Self can be found here.

Where Pliant syntax is discussed, it is said that it is original because "The Pliant parser is original in that it doesn't rely on an automaton derived from a grammar. It is simpler, but more customizable and therefore much more powerful. "

I'd like to point out that the parsing extensibility of Pliant can be found in the Forth language and I believe that Rebol may also have some of these advantages. The language Lua also comes to mind as a language with syntactic extensibility.

---

Thanks a lot

[pongo000]

Thanks a lot, Hubert. I was all ready to sit down and actually clean my desk of about two years' worth of crap, and then you come along with this hare-brained idea that dares to be different.

Needless to say, the desk will remain uncleaned tonight, while I figure out how to get the HTTP server running :)

Who died and made ICANN boss? Support OpenNIC.

Re:Programmers and the Rest of the World (TM)

[Bonker]

If you target your job niche correctly and can, you get all the perks, bennies and *pay* of system administration jobs, and very few of the headaches as a dedicated 'webmaster'. I'm the only member of the networking staff at my company who's *not* required to be on call once a week. ^_^

Re:Programmers and the Rest of the World (TM)

[BinxBolling]

The simple fact of the matter is that programmers aren't the only technically comptent people who use computers. The idea that *everyone* should *have* to program all the time to fit into this guy's rather skewed world view is ridiculous!

Where does he actually say this?

Answer: Nowhere.

The goal stated on the philosophy page is to provide a smoother path into programming so that anyone can become a programmer. Not to require everyone to become a programmer.

The fact is, despite enormous amounts of effort that have been put into building user interfaces that will put power and flexibility into the hands of nonprogrammers, these interfaces still provide only a fraction of the power that programmers enjoy. An approach that lowers the barriers to "programmer-hood" may prove to be a more fruitful path to putting real utility into the hands of the common person.

The goal isn't to have the average person writing applications from scratch. The goal is to make it possible for the average person to adjust the functioning of existing applications to better suit their needs, to write small scripts that automate common tasks, etc.

Whether or not this is an attainable goal is another question entirely, but I certainly can't fault the guy for trying.

Re:How is that INTERESTING?

[Pish Tosh]

"The greatest danger to good computer science
research today may be excessive relevance . . .
[C]ommercial pressure . . . will divert the
attention of the best thinkers from real
innovation to exploitation of the current fad,
from prospecting to mining a known lode"
-- Dennis Ritchie
Communications of the ACM, August, 1984

"What's the point?"

[Phroggy]

I'm seeing some posts here from people saying "What's the point of this? Who would use it? Why don't you just use your talents to make Linux better instead?"

I'm sure Linus Torvalds probably heard some comments like this when he was originally working on building the first Linux kernel. Why not just use DOS, or Minix, or save up some money and buy a real computer, or whatever?

If nobody ever did anything revolutionary, where would we be?

--

Huh? What am I missing...

[Arandir]

"Once upon a time, Linus took GNU system, wrote a brand new kernel for it, and it was Linux."

BZZRRT! I'm sorry, that is not the answer. Good try, but the million dollars, the new car, and the vacation for two in lovely Helskinki will have to go to another contestant...

Linus did not take the GNU system and write a new kernel for it. I don't know who your history teachers are, but their credentials need to be examined.

Once upon a time, Linus wanted a free Unix or Unix-like operating system for his new i386 computer. Minix sucked. 386BSD was in the middle of a lawsuit. GNU was incomplete. So he decided to write his own. Like GNU, he never finished it. That's because he didn't need to. The Linux distributions took the Linux engine, the GNU chassis and drive train, the BSD electrical system, and added their own body, to create what we call the Linux Operating System. Certainly GNU deserves a hell of a lot of credit, but calling it their operating system is like Abit claiming they built my computer.

If nothing else, it's useful conceptually...

[cduffy]

...as a demonstration for the folks who insist that Linux's command-line heritage condemns it to unusability. The existance of this project demonstrates that even in the (outlandish) event that any OS with a strong CLI is doomed, linux (as a kernel) still is useful.

Also, it's a nifty demonstration of pliant as a programming language.

Anyhow, you have no right to tell someone else what to code.

Programmers and the Rest of the World (TM)

[Bonker]

According to the Pliant Documentation, the creator wants to use his project to turn everyone into programmers so that they'll support FSF ideals.

This logic is a little twisted for me, but okay...

The simple fact of the matter is that programmers aren't the only technically comptent people who use computers. The idea that *everyone* should *have* to program all the time to fit into this guy's rather skewed world view is ridiculous! Take myself for example: I'm a graphical artist. Like many /. readers, I make webpages for a libing. While I *occasionally* crank out some PHP or some Javascript, the vast majority of my 'technical expertise' lies in the areas of understanding the intricacies of dozens of art, paint and drawing programs. I know what minor differences HTML code will display in certain browsers. I can administer Apache, IIS, and a slew of other web servers. I'm competent to install and administer any number of server OS's. I'm even competent enough to make choices between certain operating systems for certain tasks and requirements.

I understand the basics of how machine languages work on different processors and why programming languages behave as they do, *but* If I had to *once* sit down and crank out an application in Java or C, I would be lost. I don't have *time* to hack. I'm busy with the rest of my highly technical job.

The idea that you have to be a programmer to be technically competent is ludicrous, but one all too many hackers view as sacrosanct. Give it up, geeks.

Re:Programmers and the Rest of the World (TM)

[pen]

You apparently have no idea what a Camel Testicle Scraper gets paid (a CTSC is a very prestigous cert indeed.)

For someone who claims to know what they're talking about, you sure know how to mess up your acronyms. Being a CCTS (that's Certified Camel Testicle Scraper) myself, I cringed when I read your mangling of that prestigious certification's name.

--

Re:You beat me to it...

[DrSkwid]

well not all the things you want but more

plan9.bell-labs.com

try reading about plan9 or inferno
.oO0Oo.

Lisp a logical language?

[blamario]

I took a quick look at the Pliant documentation and I can tell two thngs so far:

1. This project took a lot of work (15 years is the claim).

2. And it was probably all in vain.

If the author took at least one of those 15 years to take a look at existing programming languages he could have used a simple and stable language as a base. How can he call LISP a logical language!? LISP is a functional language. But terminology is the least problem here. Check this quotation:

A language is a bridge between the human way of coding a program and the computer way. I assert that Pliant is the best way now available, because it addresses the bridging goal with the highest level of flexibility.

Come on, if somebody asserted to have created the best OS ever I could even believe it. But the best programming language? Such a thing simply can't exist, and event if it could Pliant has no chance from what I've seen. The only interesting part of it is the full meta-programming ability integrated with JIT-compiler, but there are languages with far cleaner meta-programming facilities. Only in the research community, though. If Pliant manages to bring more attention to great applicability of meta-programming it may be worth those 15 years of work, though.

Re:Lisp a logical language?

[scrytch]

> I'm guessing by "function arity" you mean functions taking arbitrary numbers of arguments.

You guessed wrong, about as completely opposite as it gets. Function arity refers to typing a function by how many args it takes, which is useful when the function is overloaded (which LISP doesn't support, either).

> Partial evaluation == lazy evaluation?

Wrong again. Think "currying".

> I don't know what you mean by list comprehension, but I'm willing to bet that it's not hard.

Do me a favor, learn what I'm talking about before responding to it. Learn a little about Haskell or ocaml first perhaps? I'm really too tired to flame, but you would deserve it otherwise.

--

Embedded systems

[IGnatius T Foobar]

Y'know, this might be just the thing for embedded systems. Depending on how robust it turns out to be, the combination of the Pliant userland and the Linux kernel seems like a great way to build simple, network-aware, embeddable systems without a great deal of unnecessary complexity.
--

Why not GNU Pliant?

[joneshenry]

As the code written by the project lead is all GPLed (not necessarily some contributed portions) wouldn't it make sense for the Pliant project to join GNU? The project would get some free publicity, mirrors everywhere, and an extra boost from the GNU brand. There might have to be reassignment of copyright, but on the other hand, in the long run it might be cleaner to have contributors reassigning to the trusty FSF.

Holding up okay so far...

[BigBlockMopar]

It's also the first server running FullPliant to be Slashdotted. :^)

Politically Incorrect just started on ABC. There are 100+ responses. God knows how long this article has been up, but it's still the top of the page.

I'm impressed. No one has crashed it yet, and it doesn't seem to have melted down yet.

Re:You beat me to it...

[nchip]

An XML DTD will eventually replace them, and then unified configuration might be possible. An adequate XML DTD could be self-describing and the configuration application wouldn't have know what it's configuring.

Nope. XML DTD was found to limiting, so they (w3c) invented Schemas . XML begun as a simple solution to a existing problem (need for structured data standard) has exploded to a myriad of rapidly changing standards... Try to keep yourself on track and you'll tongue will die as the amount of letter X having to be pronouced...

Downloads?

[evanbd]

OK, quick question:

I feel like playing with this, but am always reluctant to put a new OS on my HDD containing lots of useful stuff. Besides, the last repartition attempt failed (no data lost, thankfully). So, does anyone have a bootable CD ISO I can burn that doesn't need to touch the HDD? I still can't get to the web site quickly...

Re:intresting, but���

[jdwilso2]

ahh, but you see, we have differing experinces then... The majority of people with whom I am associated have gotten into linux *because* of UNIX. I attend NCState University, and up until a little while ago, the majority of machines on campus have been Solaris (Spark 4/5 and 10). It has been very useful to have a UNIX-like system running on the campus network as you can do many a thing that you can't with a windows box and an windows X-Server.

There are only two other people out of about 20 people I know who are really 'into' the opensource software/learning new things end of it. I was under the impression that we were the minority in such things.

It also follows (to me) that companies who are looking to adopt a new system would be looking for something that has been 'proven' in their minds. Many companies don't think linux to be, in and of itself, a 'proven' technology. It is (again IMO) the simple fact that (now most) linux based systems utilize UNIX ideas and technologies that gives linux this foot in the door. And (as companies enjoy such things as a third person perspective along the lines of certifications) the whole attempt at POSIX compliance gives linux ground on which to stand.

So, really, a good /. poll might be to find out how many people use linux because of innovation, coolness, unix-likeness, or whatever... Unless we've already gone there and I missed it ;-) ... But I guess my point would be that I think its UNIX-like qualities are the very basis of the success of Linux. So I ask again, what would be the use of such a system as has been presented here? Where does it 'fit in' with regaurd to the 'big picture'? Is this any more than an excersize to beef up ones own resume? Or will it be useful in the long run? Is the utilization of compile on the fly technology a step forward or a step back?

JDW

Re:You beat me to it...

[Metrol]

With my very first look into the world of *nix being RedHat, I can really appreciate the wish to simplify just where in the heck you configure things. A lot of folks here are suggesting that what you are describing is NT, which I couldn't disagree with more. NT's configuration can be as scattered, if not more so, than Linux. Folks here are talking about the registry like it's the only place you can tweak things. Apparently they've never looked at the massive amount of scattered .ini files.

In my mind when I think about centralizing configurations into logical places, FreeBSD wins hands down.

Everything system related
/etc

Stuff that you installed
/usr/local/etc

User customization
/usr/home/~

Sweet, simple, and by gosh it works. I hear folks ask, just as I did a while back, what is so different about FreeBSD from Linux. A lot of it is simplicity and logical planning of how, where and why things go where they do. I realize that RedHat has some logic to where things go, but for months I couldn't figure out the rhyme or reason to it.

Quite simply, there is an OS that has a logical design to where all the configurations go. What doesn't exist is either a GUI or Console based interface giving a user a sort of one stop shop to all those config files. Ye olde LinuxConf was trying to head down that road, but last I checked with that thing you could read the entire O'Reilly Samba book before that darn thing actually loaded up to tweak on it. That's assuming that it doesn't crash on you first.

What really is needed is two things. First, some kind of component based API that can translate the individual config files out there to some kind of standard chit chat. Secondly, a number of front ends for this at least supporting console, GTK, and QT based systems. Plug the Apache component in, tell the API where to find the httpd.conf file, and tweak in a graphical view in KDE. We definitely aren't there with that yet to be sure.

You beat me to it...

[MinusOne]

I have wanted to do something like this for a long long time. Unix, GNU and Linux have accumulated such a huge amount of inconsistencies, variations and obscurities that I can see why it is so frustrating for newbies. If I could re-architect all the programs to get rid of all of the inconsistencies without having to have any backwould compatibility it would be great. Imagine having all programs on your system store all their configuration information in one consistent place - or just one place for systemwide stuff and one place for each user's local configs. Imagine if all the configuration files had the same format. Imagine if command line switches for all commands had some sort of pattern or predictability. It would be a big programming job to make things work like this, but it would make a system that was easier to learn, use, administer and develop for. It would also be just plain more fun. The Linux kernel lends itself to exactly this kind of development, and I have been wanting to start a project like this but have not had either the time nor the energy for it. It would also be fun to participate in all the design discussions to hash out how it all would work - tha twould really be the most fun!

Re:intresting, but���

[lemonlime]

From my experience, the types of people who use Linux and who are involved in Open Source tend to be the type to try out new software just for the thrill of learning it© People who don't want to try new things generally stick with Windows©
--
Cognosco: To examine, enquire, learn

It makes perfect sense

[Anonymous Coward]

I couldn' access the site -- as it's been hit hard already, but some of the early comments suggest that this guy is waisting his time; that he should be using his talents to further linux or an existing projecct.

I think that is a very silly point of view. Should Linus T. have been criticized for waisting his talents on linux, and not helping further Minix or 386BSD? People are free to do what interests them. That's the wellspring of innovation. Sure, some time is waisted, but that's the fun and elegance af creation.

One minor point, though; UNIX is more than the utilities that are layered into a shell. The kernel API and system calls are as much a part of UNIX philosopy as bash, ls, etc. Saying that this is "without UNIX" is probably overstating the uniquenes of the project.