Slashdot Mirror
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.
The mercury compiler remains GPL, and the core Mercury developers remain strongly committed to it (I know most of them, and their leader was perhaps the first person to really introduce me to the philosophy of Free Software). Yes, they are making Mercury run under .NET. The C backend still works better than ever, and I have friends working to port it to other VM's most assuredly not controlled by Microsoft. Another friend of mine wrote a CORBA binding for Mercury, so your IPC options are certainly not restricted to .NET.
Any sufficiently advanced technology is indistinguishable from a rigged demo
--Andy Finkel (J. Klass?)
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).
Kid-proof tablet..
Lest we forget VMS, which certainly had a consistency with the command parsing.
Cat: The other white meat
Cat: The other white meat
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
Scott Stevenson
Tree House Ideas
And of course www.analog.cx.
"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+(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.
aem
-a.e.mossberg
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.
Now wouldn't it be an interesting exercise to make a Windows workalike (of course probably using lots of MS copyrighted software e.g. explorer) using only the Linux kernel, Wine, and something custom to drive the GUI layer. Not that I'd really want such a product to exist, but it'd be cool to see.
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.)
To exercise your communication skills... Explain this to your boss on tuesday. 8')
If you like to play with OS's a lot (like I do) then you might consider springing for VMWare Workstation (www.vmware.org) it's not exactly cheap, nor is it open source, but it gets the job done reasonably quick considering it can run an additional operating system on the x86 architecture you need a working linux, windows NT, or Win2k installation for VMWare to operate (I don't *think* it'll run on *BSD's but I won't swear that it won't, I've never tried)
A: You apparently have no idea what a Camel Testicle Scraper gets paid (a CTSC is a very prestigous cert indeed.)
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?"
This
The German distribution Easy Linux was supposed to have implemented a registry like feature that used text files rather than a monolithic file like Windows 95 and NT. http://www.easylinux.org/
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.
Insanity is contagious. - Yossarian
> 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
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
Scott Stevenson
Tree House Ideas
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!__________________
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.
--
try QNX. aka " queer-nux" according to some, it also fits this stuff on a single floppy. also a gui. linux without unix would be like vaginux without va linux. in otherwords, pointless.
:::
:::
Vaginux.
"eat me".
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?
__________________
page looks like it got /.'ed.
I wish him and his project well.
and why would that be?
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.
Terrorists can attack freedom, but only Congress can destroy it.
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
So it will possibly beat Perl, but not much else.
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
Also FatPhil on SoylentNews, id 863
the last but one is the penultimate.
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
Also FatPhil on SoylentNews, id 863
You can find a mirror of Pliant home site at this place and a sample site running pliant server at this one.
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.
--Giving to trolls for the benefit of us all
Comment removed based on user account deletion
Actually, the greatest dangers, in order of dangerosity are:
Take a look at the GConf 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.
that's pretty frikin cool man... but is something like this gonna be usable? I mean, people into linux are usually familiar with UNIX and know its ins and outs pretty well... But with this type of thing, even if it is simple to learn, might people want not to use it because it is unfamiliar?
And also, what practical purposes does a system like this serve? JDW
Looks like it's susceptible to the Slashdot Effect... but this time I wouldn't expect any mirrors.
So, when is someone going to use this approach to finally write EMACS-OS directly welded to the linux kernel?
-----------------------
Nicotine free Amish .sig.
Here is another offical homepage (it's just not up updated to the last second): http://pliant.cx/
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?
spoo
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.
Monkey sense
still /.ed after
fity- posts
This
Penultimate: next to the last.
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....---
<<Your post, for me, damns VB - was it intended to? >>
,ex){
//nada
e Class@@B
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.
What I would propose is just a standard place for each app to put its config files, and a standard format for the files.
/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/.....
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.)
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.
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)
.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?
Except that
spoken like a man whose registry has never been corrupted. I could tell you stories....
War is necrophilia.
i was retracting from the insulting tone, NOT from the comments buddy....
the BSD are and will be, a more mature code base,system, and architecture.
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.
As Forrest Geek says:
"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.
I'm not going like "damn I expect it to be blazin" but the site seems pretty freakin slow from Singapore. It's either the link or the server itself. I'm having like lots of read timeouts.
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.
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.
Easily. The server (as of writing) has had over 10,000 hits for it's HTTP engine being started today. See the stats for yourself. With 188 max HTTP connections, it is currently at 155 (as of page load). Such a creation serving up all these pages in so little time (thanks to the /. effect) and while the speed is crawling, the server has not crashed. I find this very intresting. I must admit, this is an excellent channel (/.) to publicize any new creation, and thus the imfamous /. effect is self inflicted...
Macx
You dont spend days programming this kinda stuff for it to "exist."
Given a reasonably level playing field, who would win a fight between a bear and a shark?
Vam
Now, the first program I looked at (being the beer program) contains a small error.
You see, the line before the last line (eh, is their a word for that in English?) not counting newlines will print "1 bottles of beer on the wall..."
function beer n arg Int n; var Str bot if n = 1 botAn improved version would be (mind you, I have not compiled this):
function beer n arg Int n; var Str bot if n = 0 console "No more bottles of beer on the wall!" eol else if n = 1 botMonkey sense
-- these are only opinions and they might not be mine.
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
> 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.
--
I've finally had it: until slashdot gets article moderation, I am not coming back.
the OS you describe is OS/400... which is soon to run Linux as is in another partition... Ralph
cd /usr/src/sys; make world
go unix!
I'm trying to figure out what YOUR point is really...
Why should this person(s) have to explain them self? Huh? So *you* will understand his motives?
As if you are somebody special and we should all bow down and explain our projects to you before we start them or something? Maybe he doesn't care.
*Maybe* he just doesn't *want* to spend his time making the Linux Kernel better (like everybody wants him to do, instead)... THAT is a good enough reason..
People do this kinda stuff all the time. It's nothing new. Maybe he just felt like making his own little thing. Maybe he doesn't want to improve an existing thing. Soooooooooooooo WHAT... Why should he have to explain him self?
Why are there so many distros of Linux? Why can't we all just work on Red hat and make it better? Why do we need Debian? Why are there so many text editors? Isn't VI good enough? Why can't we all just improve that one and get rid of emacs?
Bah. Get a life. You people whine over the stupidest things.
-----------------------
Jeremy 'PeelBoy' Amberg
And you should try to get old compaq's to run linux (and X and esd ...) ;)
Don't discredit people because of their age. Discredit them 'cause they're idiots.
Information wants to be free like speech wants to be free, not like we want beer to be free.
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...
>> the OS you describe is OS/400...
Not really - unlike most Unix developers I am quite familiar with OS/400. What I want is something with some features of OS/400, some features of Windows, some features of Unix/Linux/GNU/BSD and so on. Just about the only thing I liked about OS/400 was the fact that if you didn't know the command to do a particular thing you could, with the assistance of the OS, find the command and get all the parameters and options. That was pretty handy for me, a Unix guy given this machine to port software to without any real training or instruction on it.
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! ;)
>>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.
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
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
http://virtuelvis.com/
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.
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.
Sounds like you're talking about the Windows Registry.
Homogeniety creates more problems than it solves. Diversity has it's own problems, but gives us all something to argue about. It sort of sounds like you're wishing that world of computing will coelesce into some kind of perfect crystaline unity. It won't. Not ever. Thank goodness.
If you want to make the world a better place, find something bite sized to work on, and chew on it.
--Lawrence Lessig for Congress!
This may be exactly what I need for some embedded applications work I will be doing in the future. I am sick to death of dealing with M$ crapware but simply too overworked to tackle the near-vertical learning curve necessary to get into *nix. This could be the short path to a reliable embedded environment.
The thing I wonder about is, will the Linux drivers for various devices work with the Pliant shell OS? This is what would make this small environment practical, since a major obstacle lately has been future product support when hardware compatible with the software becomes unavailable. I have several apps running Windoze 3.11 that won't work in 9x or NT unless they are partially rewritten, and as long as at least some hardware of all relevant types is supported under Linux it has appeared to be a very interesting alternative. But the learning curve! And I all my fscking projects are due last week! I am really looking forward to the server coming back up so I can take a closer look at this thing.
Brackets contain world's first nanosig, highly magnified:[.]
Just FYI, the name for the thing before the last thing is second-to-last, or next-to-last. Ex: in the next-to-last line, blah blah blah.
Mod down posts with a "Free Mac Mini/iPod" sig, they're spam!
Some good points you've made here. This 'Pliant' software shows just how versatile the Linux kernel is.
> 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.
.
It's called the Windows registry . .
Total memory on this system: 188 MB
Memory consumed by this Pliant process: 13 MB
Memory consumed by other processes and kernel: 32 MB
Memory still available: 143 MB
That's the new server actually. So it isn't so bad *hehe*
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.
Friends don't let friends use multiple inheritance.
Oh yeah we're raking in the dough. I make less than a Camel testicle scraper (per hour that is)
This
I don't think there's any reason to be so insulting. I made a mistake, in my haste. I *meant* to say: "
Solidus Fullstop, Esq.
Solidus Fullstop, Esq.
"hey, you stole that sig from me!"
I think the whole point of this, though I haven't been to the website, since it's /.'d, is to show that a kernel is not a complete system. We all know this, but it doesn't really sink in, until someone strips away all the Unixisms. Someone could build OS/2 atop the Linux kernel, someone could build EXPLORER.EXE atop the Linux kernel, someone could do anything they wanted, using Linux -- not using Unix. Obviously, there are Unixisms in the kernel, but these Unix metaphors are not necessary. This might be the type of development that a lot of people could get into - people who want to develop systems.. but don't / can't start all the way back at square 1. Given a rock solid, proven foundation to work with, you can just get up and start coding something.
"Champagne for my real friends - and real pain for my sham friends!" http://ericblade.postalboard.com/
Do you also disapprove of writers who write novels and plays instead of instructions for stereos? Or shake your head at a painter who paints canvases instead of houses?
This is a good thing, despite how practical it is. Any (new/innovative) development in the CS field is good, despite its applicability.
Let those who love the field and have passion do what they want, practical or not. The corporate world will supply 'practical' uses.
Just my thoughts.
--
minusthink [Code poet or super hero? (you decide)]
"when life gets complicated, I like to take a nap in a tree and wait for dinner" - Hobbes.
Perhaps you'll like to visit my web site. It's all HTML 4.01 validated and compliant.
--------
Genius dies of the same blow that destroys liberty.
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.
I think we've pushed this "anyone can grow up to be president" thing too far.
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.
I think we've pushed this "anyone can grow up to be president" thing too far.
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
>People who don't want to try new things generally stick with Windows
C'mon now...using windows has nothing to do with trying new stuff or not. Just because you don't choose to use....ah nevermind
It is implied exactly nowhere on that website that *only* Tibet should be freed, and the rest should be ignored. In fact, please note the following partial quote: "...that helping the[sic] Tibet get free is an obvious way to start with." See that 'to start with' bit? That certainly is not saying Tibet should be the *only* group freed.
Why Tibet first, then? Well, note his use of the phrase, "...I believe...". That explains it as well as anything ever will.
A journey of a thousand miles begins with a single step...
Hokey statistics and ancient misconceptions are no match for a good thought in your head, kid!
Comment removed based on user account deletion
This is an interesting idea, and I guess we should praise Mr. Tonneau for a great deal of originality and a lot of hard work. Beyond that...
Quite frankly, I see some serious flaws with the reasoning behind this project. It seems that Mr. Tonneau believes that the reason a lot of Free Software is bad (read big, buggy, etc) is not bad design or hasty implementation, but because it was written in C or C++.
He makes some very strange remarks about the desirability of language flexibility; talking about how limited C/C++ is because you can't build your own "for" operator. This strikes me as completely bogus. Yes, I understand that it is possible to extend a language in this way.
However, your brand new language construct (say "really_cool_for") either remains private to your own code - in which case you increase the cognitive load of someone else reading your code - or it achieves some level of public use, gradually adding to the size of the language in common use. Eventually, you'll have several loosely overlapping versions of the same language - all perfectly legal of course, according to the way he's defined the language - just not necessarily intelligible.
Granted, C and C++ can feel like this at times. The first time you hit someone else's wonderful object hierarchy with loads of overloaded operators and inheritance or macros can feel like you're programming in a new language. However, you're not.
He also points out that while C++ can define new classes (eg. complex), it doesn't really understand how to optimize them. Instead, he offers, we should tell the compiler what optimizations are possible.
His example, as it happens (concerning complex numbers - implementing x*2 as x+x) is simply wrong, suggesting that he doesn't really understand what's happening in modern compilers very well (constant propagation and inlining would take care of this example quite well). However, let's assume that we're talking about more complicated classes, which the optimizer cannot handle so easily.
Even in this case, such a feature is broken. The "how to optimize this code" module becomes part of the code; yet another thing that can be done wrong, or that can get out of step with the actual code. This will wind up as a glorified #pragma feature, with all the same problems.
In fact, I'd say the the language extensibility will make it very hard to do any complicated optimizations on the code at all. About the only thing that makes interprocedural optimizations doable in C/C++ is the fact that procedure semantics are almost always preserved in C/C++; when they aren't, it's obvious (exceptions, setjmp/longjump, a call to exit). If you can magic up your own funky interprocedural control structures (maybe because you _really_ miss continuations), then either the optimizer punts, or you have to build a nice little language so that you can tell the optimizer just what the hell is going on with your gnarly new control structure.
There are serious interactions between new language features and optimizations; garbage collection interacts with practically everything, for example. Dealing with these interactions in conventional compilers (where you know what language features exist) is hard work for smart compiler guys. Doing it automatically is probably going to be just too hard.
Another thing: I find it a little odd that the guy can write several paragraphs on how hard it is to write code across multiple platforms, a few more on some of the more obvious flaws and weaknesses of C/C++, and not mention Java. Yes, I know his language does rather more things than Java (most of them bizarre). It's just a bit disingenuous to go from talking about more obvious C/C++ lossage (that's addressed, however well or poorly, by Java) to "you need to use my language", without mentioning that C/C++ are hardly the only game in town.
And finally, what I thought was the funniest quote by far:
"For big-project managers, Pliant resembles an ideal linker since you can write various
pieces of a project in various programming
styles, with each part using the optimum style
for its functional needs..."
How's your blood pressure, "big-project managers"?
Comment removed based on user account deletion
But VB has lured legions of programmers into bad coding practices, and it is totally unsuitable for projects with more than three or four programmers. And the more you use it the less rational its "features" appear.
I bragged about my Karma at a job interview but I didn't get the job.
To all those who see my ideas as similar to the Widndows registry i say that I agree to a certain degree. The registry is great for storing config info, but I hate the binary-only aspect of it, and the "corrupted for one, corrupted for all" aspect. IBM actually implemented a registry-like database called the ODM under AIX. It works, but suffers many of the drawbacks of the Windows registry. What I would propose is just a standard place for each app to put its config files, and a standard format for the files. I would want text-only config files so that the could be hand-hacked. Something like a /config directory at the top level, with each app making a subdir with the app name, and maybe a version number under that - 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/.....
Many other re-organizations of where files go are possible if you throw out any backwards compatibility. I have not thought this out to any great degree or read any relevant documents for existing system. I guess I should do some research and make some proposals!
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.
Any sufficiently advanced technology is indistinguishable from a rigged demo
--Andy Finkel (J. Klass?)
Here's the link, I hope slashcode won't break it:
http://developer.apple.com/techpubs/macosx/
Cocoa/Reference/Foundation/ObjC_classic/
Classes/NSUserDefaults.html
Just join those three lines.
Because the kernel was written from scratch, Linux is technically not Unix but a new operating system .
Nonetheless, short of replicating the code from BSD, Linux owes much of its conceptual and architectural design principles to the example of the BSD. At the same time, Linux has been careful to avoid mistakes the BSD has made. And finally, in its commitment to portability and simplicity, Linux has carried the torch, lit by the fathers of the original Unix, farther than any other systems. The legacy of BSD and other Unix-bases operating systems proved valuable resources and inspiration for the development of Linux. To strip the kernel is just plain foolishness!
Solidus Fullstop, Esq.
Solidus Fullstop, Esq.
"hey, you stole that sig from me!"
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.
Brackets contain world's first nanosig, highly magnified:[.]
Well, you don't maybe. I've written plenty of complicated things just because. Why not ask the creator?
There was such a thing a few years back. You could guess at the command line options and be right. It was incredibly consistent. The authors obviously knew unix and wanted to start all over with a good design. Graphics were fast too cause it didn't need X11. And good filesharing w/o NFS. Had a cool editor build into the windowing system. It was called Aegis/DomainOS. It was from Apollo computer in Chelmsford, MA before HP bought them and killed it. And it used to scream in 4MB. If you wanted to run the cool gui debugger (unheard of at that time) you needed about 8MB. They started adding Unix stuff to it around the time HP bought it and it got slow and ugly. But it WAS COOL. see comp.os.apollo.
::applause::
--
minusthink [Code poet or super hero? (you decide)]
"when life gets complicated, I like to take a nap in a tree and wait for dinner" - Hobbes.
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?
__________________
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!
~ radiographite: art by john shepard
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.
---
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.
The first rule of web design is plagarism. I would be *flattered* if you ripped off my designs! ^_^ Feel free:
http://www.coredata.net
http://www.furinkan.net
http://www.harringtoncc.org/ (This one's a little out of date. They may have changed it a little, but the original design is mine.)
http://www.kennethwyatt.com - The art is Mr. Wyatt's, the site design is mine.
The next Slashdot story will be ready soon, but subscribers can beat the rush and slashdot the links early!
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. ^_^
The next Slashdot story will be ready soon, but subscribers can beat the rush and slashdot the links early!
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.
"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
When did 90% of Slashdot readers become Late Adopters?
Pliant is the third or fourth new project I've seen in the last few months that has been mostly bashed for forward thinking. (The other I remember clearly was Interpreted C++. A while back I remember strong Berlin bashing.) This typically happens when Late Adopters and opportunists fear things that add to what they must know, even if it improves their lives! Typically this is because they are too DUMB to understand what they are doing or how it can be improved!
I have turned up my threshold to 3 and that helps filter out lots of uninformed negativity about general subjects, but these forward-thinking projects always promote such comments to 3 or even 5! Do we need a second Karma value that expresses the constructiveness of a post? Because I have no need to see "It's been done before" or "Too bad this guy wasted his time" posts. If you know of similar systems, why not point out their good values and a link to them. And what you feel is an advantage/disadvantage. That's it!
Yes, OF COURSE projects likes this have been tried before. Perhaps they weren't perfect, were badly timed, or should come back. But anyone sitting around thinking C++/Java and Unix are the final answers should get back to wasting years programming broken, unmaintainable, large systems for their IT department and let the big boys discuss things!
I think a very reasonable discussions would be about how COBOL should be used in most db/business apps. Perhaps extended a bit. Could you imagine how that would go over here?
"The first server running FullPliant can be accessed at: [this site]."
:^)
It's also the first server running FullPliant to be Slashdotted.
This may be offtopic, but I'm not a troll, and I think it is worthy discussion because it was mentioned on the site that "Free peoples is even more important than free softwares." -
I agree with this statement, but I do not see why the people of Tibet are so special and why should we invest in our resources on only freeing one group of people?
What about the Chinese people? The people of China are themselves not free, and should be freed from the communist dictatorship. Human rights should be restored to all people in China and not just Tibet! Going even further, then why should only the people of China and Tibet be freed, where there are millions more people held captive to their Government in many other regions all around the world?
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?
--
$x='S24;r)>63/* h@<5+oZ)32"5cz';$me='phroggy'x$];
$x=~y+ -xz+\0-Tx+;print$_^chop$me for split'',$x;
You have a much easier job than a Camel testicle scraper. He deserves the higher pay.
"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.
A Government Is a Body of People, Usually Notably Ungoverned
But it looks like the TCP/IP stack needs some work.
splat!
To bad he didnt mention what hardware it was running on...
You apparently have no idea what a Camel Testicle Scraper gets paid
:)
i guess we could just ask one of those guys who travel around the desert with the camels - surely one of them have to clean the camels when they get dirty testicles
...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.
The scope will be the same as the one of the last year (see ASPIC 2000) and we hope the second edition will be a bit less "confidential"...
Having had to hack SERIOUS projects in VB, I can comfortably say that, while it is a useful tool for simple projects, it quickly becomes unworkable. Pretend OO, crappy error handling model, and a slightly bittersweet candy shell. Thank God for Delphi.
meh.
According to the Pliant Documentation, the creator wants to use his project to turn everyone into programmers so that they'll support FSF ideals.
/. 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.
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.
The next Slashdot story will be ready soon, but subscribers can beat the rush and slashdot the links early!
well not all the things you want but more
.oO0Oo.
plan9.bell-labs.com
try reading about plan9 or inferno
There are places where the networks are not touching,and there are places where they are-Boeing's Lori Gunter
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.
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.
--
Tired of FB/Google censorship? Visit UNCENSORED!
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.
I like Windows 2000, but since when could it be configured from a CLI?
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.
Fire and Meat. Yummy.
A mini distro ...
Free Techno/Jazz/DNB/MI Music by guys obsessed with monkeys!
UNIX-likeness + GNU tools.
I installed slackware a long time ago simply so I could better learn UNIX by having control of the whole system rather than a university user account on a sun.
Plus I liked the GNU tools. Prior to installing slackware I was using DJGPP, the DOS port of gcc which also came with DOS ports of GNU stuff like less and grep. RHIDE rocked too.
--
What!?!
Its a good thing Linus didn't take this kind of advice when he started on Linux. Hell, even Steve Jobs and Bill Gates probably ignored this kind of thinking when they were getting started.
Isn't this how the NeXT system started, with a new set of cool tools wrapped around a BSD kernel? Not that it's a bad idea, just that it's been done before; I'm surprised anyone here doesn't understand it.
second society
Favorite Ritchie Quotes:
Please bid on this Karmann Ghia! Please pleas
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...
signatures pending - ansa@kos.to - (dont mail there)
VB might as well be interpreted, all of its functions are in DLL's - mostly MSVBVM DLL (a clue it stands for microsoft Visual Basic Virtual Machine).
You need 1.5 MB of DLLs and controls to even run a hello world program!
no sig.
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...
You just described Windows 2000/NT:
All system information is stored in one place. All users info goes into one certain place under that users's profile. Everything works in a set, systemmatic way. Yes, this limits Windows' "hackability" sometimes, but that's a tradeoff I'm willing to make for the standards and support I get.
Linux is a great "fooling around" tool for me, but the complexities aren't worth any gains I may receive over Windows 2000 at this time, in terms of using it as my primary OS. That could change in the future.
-
The IHA Forums
Natural != (nontoxic || beneficial)
Click:R eference/Foundation/ObjC_classic/Classes/NSUserDef aults.html
http://developer.apple.com/techpubs/macosx/Cocoa/
-- Slef
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.
/. 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?
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
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.
The line must be drawn here. This far. No further.
Hi all,
/.ed Is it another OS. If so whats the advantage over Linux/Unix/Win/Beos/HPUX/.........
Can anyone explain to me what is FullPliant? I can't seem to get the site. Guess its been
ukNutter
Man, I saw that ".cx" in the link, and even though the rest of it wasn't It, I still thought long and hard before clicking on it :).
The web page claims that it uses a "dynamic compiler". It compiles the programs as it reads it. Isn't this the same thing as an interperted language such as Visual Basic, Perl scipts, and of the such with the same problems (such as it is normally slow)?
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!
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
Cognosco: To examine, enquire, learn
http://cognosco©datablocks©net
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.