Linux -- Without Unix 180
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.
Re:Language barrier (Score:1)
Re:"What's the point?" (Score:2)
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:You beat me to it... (Score:1)
Re:It makes perfect sense (Score:1)
Re:Is UNIX its APIs? (Score:2)
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:What is the connection with goatse.cx? (Score:1)
Re:Don't Point, it's not polite (Score:1)
"GNU" consisted of a respectable collection of tools, and that's all.
If anything, the comment could have been re-phrased better as Linus+Minix [cs.vu.nl]+(gnu tools)=Linux, but (apologies to Andy Tannebaum [cs.vu.nl]) I don't believe Linus ever used any of the minix source [cs.vu.nl] on his development path, since he says just that in the initial announcement [www.dina.dk] of his plans.
aem
Re:How is that INTERESTING? (Score:2)
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.
Re:"What's the point?" (Score:1)
Is UNIX its APIs? (Score:2)
Good practice for your communication skills (Score:1)
Re:Downloads? (Score:1)
Re:Programmers and the Rest of the World (TM) (Score:1)
B: MCSE, I specifically don't hire them.
C: MCSE, CNE, CNA, A+, CLP, yadda yadda all well and good but when the Notes Server won't stay up for more than 12 hours and you have to deploy a 2000SQL, a 2000IIS and 3 dedicated workstations and your assistant's wife had a baby and you're going to Disney with your family (whoever they are) Camel Testicle Scraping looks good. They only work 10 hours a day.
D: I don't want anymore Sys Admin's out there.
E: I do like the part where I can surf for porn and call it "research"
F: I only got 15K more this year.
G: At the end of the month I still owe then $20 bucks b/c they are charging me rent since I sleep there.
H: Ha ha
I: What do you consider "raking it in?"
Easy Linux (Score:1)
Re:intresting, but... (Score:2)
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? (Score:5)
> 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? (Score:2)
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 (Score:2)
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!
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? (Score:5)
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.
--
Re:You beat me to it... (Score:1)
:::
Extensible Languages (Score:2)
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?
__________________
boom. (Score:1)
I wish him and his project well.
Re:Extensible Languages (Score:2)
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:Ouch. (Score:1)
Re:VB Generates real code (Score:1)
Re:Programmers and the Rest of the World (TM) (Score:2)
Certainly people should opt to be in the former group, in terms of the ends.
Re:Lisp a logical language? (Score:2)
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 [sourceforge.net] if you want to see what I mean. Functional programming in Lisp! Amazing!
-sugarescent
Re:VB Generates real code (Score:1)
It has two (as far as I can see) library calls inside it. C/C++ and Pascal and Fortran and Lisp/Scheme would run rings around this.
Your post, for me, damns VB - was it intended to?
FatPhil
-- Real Men Don't Use Porn. -- Morality In Media Billboards
Re:1 bottles of beer on the wall (Score:1)
pen- implies 'near'
The penultimate line is nearly the ultimate (last) line
A peninsula is nearly insular (an island)
A penumbra is nearly umbral (a shadow).
That's all I can think of.
-- Real Men Don't Use Porn. -- Morality In Media Billboards
Mirror !!! (Score:1)
Re:1 bottles of beer on the wall (Score:1)
Re:You beat me to it... (Score:1)
Now having all the configuration data in one place is not necessary. Software can just access the configuration files spread throughout the system.
But this is labourious and far too much work due to the inconsistencies in plain text configuration files. They have a million different syntaxes, and any configuration program needs to learn each one. They need prior knowledge about the piece of software they're configuring.
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.
Nice idea, kid. I can see you're an ideas man. Ho-ho.
Re: (Score:2)
Greatest Danger To Computer Science? (Score:1)
Actually, the greatest dangers, in order of dangerosity are:
Re:You beat me to it... (Score:1)
Take a look at the GConf [gnome.org] library. It uses a standard API for programs to access their configuration data and stores this individual conf files using XML, and is already in use by Nautilus and Evolution. It probably wouldn't be too hard to extend this program to work under Windows or whatever OS you like.
intresting, but... (Score:1)
And also, what practical purposes does a system like this serve? JDW
No better (Score:3)
Re:More than just an OS (Score:1)
So, when is someone going to use this approach to finally write EMACS-OS directly welded to the linux kernel?
Re:Why not GNU Pliant? (Score:2)
-----------------------
Another location (Score:4)
Re:"What's the point?" (Score:1)
Example
If you wanted to recompile a whole linux distribution, you'd have a lot of compiling to do...
But under FullPliant, all you'd have to do is compile the kernel then compile the OS.
Sweeeet.
Are you god?
Re:Another location (Score:2)
Release 53 [pliant.cx] (the current version) is what Hubert is presenting at the location in the original story.
They are both at pliant.cx.
/bin/pliant ? (Score:2)
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:No better (Score:1)
Since everyone who's trying Pliant is essentially mirroring it (the default site for the http server is the same as their homepage [pliant.cx]) I wouldn't worry too much ;-).
Sing to a Paul Simon song (Score:1)
Re:First system complying with WHAT? (Score:1)
--
The word is Penultimate (Score:1)
Re:You beat me to it... (Score:2)
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 (Score:2)
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
}
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@@2UCRuntim
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... (Score:2)
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
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:A small question (Score:1)
And the java advocates will tell you that java is "almost as fast as C++". I'll believe it when I see it. The difference with C++ is that you can profile it and optimise the performance critical chunks of code until they're as fast as C. In fact using tricks like reference counts, you can sometimes make it faster. I'd agree that the slower languages (compile-to-vm) are fast enough for a lot of things, but it's dishonest to call them as fast as C++ or C.
Pop-quiz: 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.
Re:We already have it (Score:2)
Except that
Re:You beat me to it... (Score:1)
Re:Christ stop kissing each other's dicks already (Score:1)
the BSD are and will be, a more mature code base,system, and architecture.
Linux Ain't Unix Either. (Score:1)
But this project goes to show us that we don't have to be designing set-top boxes to create something new for Linux. For example, I'd like a Linux version that boots from CD and serves as a front-end for MAME, that might be suitable for a PC installed inside an arcade cabinet. Perhaps it would run on a Dreamcast, too. Perhaps a whole new home-brew set-top box industry can begin.
Is UNIX its APIs? I think so. (Score:1)
"unix is as unix does."
However, Mach isn't a good example of this,
since, even though one can have a Unix-
compatibility layer, one isn't required to
do so.
Seems slow (Score:1)
Anyway it looks like the TCP/IP stack needs some serious reworking. "TCP connections used: 73/188"
Plus some CPU optimisations.
I'll be pretty keen to try it out if I could. Maybe make it the next big "floppy router" thingie.
Self promotion (Score:1)
The Pliant author certainly isn't shy about proclaiming its originality. If someone has to remind you that something is "the best" or novel it generally isn't.
Re:A small question (Score:2)
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? (Score:2)
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 (Score:2)
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... (Score:2)
VB Generates real code (Score:2)
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.
Oh no, not another one! (Score:3)
They claim they are trying to make you a programmer. This page [pliant.cx] 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.cx]
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
"How is it interesting?" (Score:2)
Re:You beat me to it... (Score:2)
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 (Score:2)
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 [pliant.cx] section of his site.
Re:eh? (Score:2)
--
Re:Interesting, here are similar technologies (Score:2)
Caution: Now approaching the (technological) singularity.
Re:A small question (Score:2)
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? (Score:2)
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 [xanalys.com] of the Common Lips HyperSpec. Maybe you also forgot how to declare the types of arguments your function takes [xanalys.com].
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 (Score:2)
The Mercury [mu.oz.au] 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 (Score:2)
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 [pliant.cx] 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 (Score:5)
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 [gnu.org] (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 [linuxworld.com] 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? (Score:3)
Heresy! Burn him at the stake!
Interesting, here are similar technologies (Score:5)
Interesting links on Self can be found here [dmoz.org].
Where Pliant syntax is discussed [pliant.cx], 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 [rebol.com] may also have some of these advantages. The language Lua [puc-rio.br] also comes to mind as a language with syntactic extensibility.
---
Thanks a lot (Score:3)
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 [unrated.net].
Re:Programmers and the Rest of the World (TM) (Score:2)
Re:Programmers and the Rest of the World (TM) (Score:2)
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? (Score:5)
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
Re:VB Generates real code (Score:2)
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
"What's the point?" (Score:5)
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... (Score:2)
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... (Score:2)
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) (Score:5)
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
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:You beat me to it... (Score:2)
plan9.bell-labs.com
try reading about plan9 or inferno
Lisp a logical language? (Score:3)
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.
Embedded systems (Score:3)
--
Why not GNU Pliant? (Score:4)
Holding up okay so far... (Score:3)
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:Lisp a logical language? (Score:2)
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.
--
Re:Oh no, not another one! (Score:2)
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 [bell-labs.com]. 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.
Re:You beat me to it... (Score:2)
Nope. XML DTD was found to limiting, so they (w3c) invented Schemas [w3.org] . 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? (Score:2)
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:Programmers and the Rest of the World (TM) (Score:3)
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:intresting, butİİİ (Score:2)
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
JDW
Re:You beat me to it... (Score:2)
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... (Score:3)
Re:intresting, butİİİ (Score:2)
--
Cognosco: To examine, enquire, learn
It makes perfect sense (Score:3)
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.