Slashdot Mirror

However, there are several (at least 8 plus 3 MIA) Forth operating systems afoot. Including one which is implemented as a Linux kernel thread.

I need to finish my OS for when Linux goes down in flames. Then I can be the author of the most popular free OS instead of the least popular.

Isn't that what open source is all about? Who is most popular?

Try these OSes on for size:
Retro Forth
AtheOS
VSTa
TinyOS

Aix is a microkernel design, At the time I started using it ('93 / aix 3.1) this was 'common knowlege' and the basis was Mach. I beleive that's with extensive IBM mods. Yes I also remember the time when 'Workplace shell' was going to sit on a microkernel under aix, os/2 ... That was also the days of IBM's SAA :-).

You may also remember that the (ca) '96 timeframe was when IBM was offering it's microkernel investment to competitors. I (still) beleive that this was on the basis that they had migrated os/400 off of it's mini-platform onto RISC and DEC and HP were looking at the same problem with a need to move VMS and MPE respectively onto their RISC platforms.

I know for a fact that the AIX VM has the same design (benefits and limitations) that Hurd has been dealing with in their Mach underpinning. IT's an approach to the VM which to my knowlege is unique to Mach/osf1.

I'll offer the following assertions that AIX is based on Mach.

AIX/ESA, runs native on S/370 and S/390 mainframes, based on OSF/1. AIX [rs/6k] was to have been base for OSF/1 until Mach was chosen instead. I hope this subsection is converging : ref

The Mach microkernel technology developed at Carnegie Mellon University serves as the basis for IBM's microkernel work. On the Mach base IBM is experimenting with new ways of implementing low-end environments, developing stand-alone file servers, integrating multiple operating system personalities on a single computer, ... For instance, the low-end AIX implementation on Mach currently runs as a dominant personality and supports an environment for running DOS programs as a secondary personality. ref

MACH isn't a UNIX system either but is the basis for interesting UNIX kernel dev elopments. The DEC UNIX kernel is build on MACH (as well as the GNU Hurd, NextSt ep/OpenStep, Apple's forthcoming Rhapsody and IBM's OS/2 for the RS/6000). ref

IBM's own AIX operating system is based on a different Unix kernel, called the Mach kernel, which was created at Carnegie Mellon University in Pittsburgh, but many of the layers of Unix functions that ride on top of this kernel are apparen tly based on Unix System V ref

See also e2[microkernel]

These are not buzzwords. 'Strawman' is a common name for a typical logical fallacy -- quite CS and unbuzzwordly for me. For a great explanation of the difference between buzzwords and terms which serve a purpose look at this list, from tunes.org:

Proeminent features built around this reflective architecture will include unification of system abstractions, security based on formal proofs from explicit negociated axioms as controlled by capabilities, higher-order functions, self-extensible syntax, fine-grained composition, distributed networking, orthogonally persistent storage, fault-tolerant computation, version-aware identification, decentralized (no-kernel) communication, dynamic code (re)generation, high-level models of encapsulation, hardware-independent exchange of code, migratable actors, yet (eventually) a highly-performant set of dynamic compilation tools (phew).

These are not buzzwords. Now, for comparison, here's a bunch of buzzwords:

"A proven 32-bit cutting-edge state-of-the-art industrial-strength Y2K-compliant zero-administration plug-and-play industry-standard Java-enabled internet-ready multimedia professional personal-computer Operating System that is even newer and faster yet compatible, with a user-friendly object-oriented 3D graphical user interface, amazing inter-application communication and plug-in capability, an enhanced filesystem, full integration into Enterprise networks, an exclusive way to deploy distributed components, seamless network sharing of printers and files." (yuck)

I couldn't agree more. These days, you can do very complex things with computers, BUT: at the same time, it becomes increasingly difficult to do really simple things.
Shouldn't more powerful systems besides giving you more possibilities, also make simple things even more simple or easy? They should! But they don't.
I think it's really a fundamental problem with today's Operating Systems. For instance, to create a simple 'Hello World' program, you need an ever bigger set of development tools. Logical? No!

On any old homecomputer, it looks really simple:

10 PRINT "Hello World"
And to execute it: RUN

Why is it more difficult to do that on today's systems? Because, the "Hello World" program has to support all the added features of today's system. And that's the fundamental flaw. It should be the other way round, where the "Hello World" progam would still look the same, and such extra features would be supported another way. That's what an improved OS should do.
I found a project on the web recently that makes a serious attempt to find a solution to this:

the TUNES project

Anyone seriously interested in thoughts similar to this should look at the Tunes Project

..to anyone who has ever used a Lisp Machine, Forth Machine, Smalltalk system, or any one of the other dynamic, interactive programming language environments.

Here's a useful link:
No-Kernel systems.

Have you seen The Tunes Project?. It sound like what you claim to want, even if it's still a work in progress...

If I wrote a C program and started it as

void main(void, void)

struct person {char * name; time_t date_of_birth; colour_type eye_colour; long double height; long double mass; int google_pages;}
main(struct quaternion {long double real, i,j,k;} argc, struct train_schedule {unsigned int stations; struct stationtime {struct station {char * name; long double longitude, latitude;} station; time_t due_intime, due_outtime;} * station_list; unsigned int carriages; struct carriage {int first_seats, second_seats,third_seats;} * carriage_list;} ** argv)

If web designers insist on writing web pages which either do not conform to standards or which misuse deprecated elements (such as <font face="symbol">&yen;</font> (or with an absolute code) for &infin; (Slashdot won't display certain characters, so I've had to literalise them to prevent them being stripped out completely) when many systems don't have a Microsoft symbol font - I see this problem far too often (although that site does warn users)), they should expect their page to fail somewhere.

Of course, the DHTML bug is bad because with it, Mozilla 1.2 is not a conforming implementation of the HTML 4.0 standard and so no company will dare use it (just as few companies (excluding Microsoft) will dare use GCC (any version) due to lack of C99 support.

And you forget the most important problem of Microsoft Internet Explorer - it does not work at all on any Unix system (the Solaris and HP/UX versions have been withdrawn), on any GNU system or indeed on almost all operating systems. Mozilla has the virtue of being somewhat more portable (for example, ports to BeOS and OpenVMS are in the pipeline).

Haha. And one day, bold people will even implement this VM on a true microprocessor! Imagine that! Sorry, but this was created long ago, with the whole family of Lisp machines (yes no C, only Lisp used as a system language), see one of the last attempt

Ha! Are you a programmer? Do you know such
prominient computer language as Eiffel?
BTW, here is a good page reviewing languages:
here
A lot of useful and robust programs were written on that language;this strange language enforces
simple "for" loop as follows: you should write preconditions for loop, postconditions for loop, invariant of the loop and the loop itself.
I saw good and robust software written on such strange language - it worked.
Legal is like Eiffel...

• AROS
  
• Virtual Acorn (an emulator but which emulates an OS, indeed)
  
• MenuetOS
  
• Debian GNU/Hurd
  
• Plan9
  

Most people would define Unix systems exactly this way. Look through the man pages, filled with small, tight little programs, each one doesn't do a whole lot, but they allow a whole lot of freedom to do massive things quickly

Try writing quick filters for data in windows, without downloading "Bob's little filter helper" or some other idiot program.

TUNES

Are you looking for fun? It's based on Lisp - that the real fun!

Features of TUNES;

Review of other systems;

TUNES

Are you looking for fun? It's based on Lisp - that the real fun!

Features of TUNES;

Review of other systems;

TUNES

Are you looking for fun? It's based on Lisp - that the real fun!

Features of TUNES;

Review of other systems;

The abstraction of an "operating system" is merely a convenience to developers and users. Microsoft has every right to define what their "operating system" consists of--and no one can tell them different. To define what an "operating system" consists of for them and to force them to adhere to this government produced definition is no less than Microsoft being tried and found guilty of thoughtcrime.

See TUNES to expand your definition of what an "operating system" could be.

Microsoft domination? Patents? HA! What scares me is when the government is actually considering telling an organization what to think or produce. Will Linux/BSD/etc. operating systems be forced to adhere to what the government defines as an "operating system?" If not, then that seems a little bit of a double standard (and in this case the government has turned from pro-competition to plain anti-Microsoft). This isn't just about bundling a stupid interface to the standardized web. That issue is about as moot as bundling a steering wheel with a car. This is about the government defining what a car consists of to General Motors, and forcing them to adhere to that definition.

Perhaps the real tragedy is that too many people define an "operating system" as what Microsoft considers an "operating system." And the tragedy continues on Slashdot and the Linux/BSD community. Where people bicker about marketing nonsense words such as "innovation" and have a vision of an "operating system" as this esoteric *ix/desktop metaphor hotchpotch. If anyone thinks changing Microsoft's definition of an "operating system" will have any effect in bringing Linux/etc. to the "masses" then they are seriously wrong. If anyone actually thinks Linux/BSD are better for Microsoft's user base than Windows, they would be seriously mistaken.

Some Other Info for Scroungers

I'll name some.

Login procedure is more or less the same, as are adding users/removing users.

Configuration is the same: stuff everything in /etc using a different format for each program and then clutter up users' directories with user-specific configuration.

The GUI is the same. Instead of Motif (or whatever X11 had at that time) we have KDE, GNOME, WindowMaker, etc. The underlying mechanism, X, is the same.

Applications more or less talk to each other in the same ways: using pipes and occasionally this highly advanced technology called "shared memory." What a concept. Linux has nothing that compares to Windows OLE, COM, etc. The framework is there, sortof. The backing of it is not, however.

Everything is written in C (with the occasional C++ program). I'm talking programs which are compiled directly to machine language (i.e. not Perl, Python, etc.). The libraries remain the same. The documentation (man pages) is probably the same. The only difference is now Linux is discovering DLL hell that Microsoft world has already seen (though not the same; Linux DLL hell is caused by an over-abundance of unneccessary DLLs mostly from GNOME/KDE applications and for the most part not version conflicts, though they do exist too).

The concept of a "program" is the same as it has been. A program is written, compiled and is static. There is no concept of persistence in Linux. There is no type of garbage collection on a system-wide level (which is much needed with today's 100+ gig drives).

The pipe interaction between programs is still ASCII text-based. It has not progressed to "object-based" or any higher level abstraction which is needed to bring the piping concept into the GUI world seamlessly. It will for the most part remain a text-based anomaly once CLIs become weeded out by GUIs (this will happen if there is any type of advancement in the GUI area--but I'm skeptical if the OSS community can actually advance the state-of-art rather than simply duplicate it).

Okay, enough for now. I could go on about lame user permissions and granularity. Instead I will direct you to TUNES. It's more useful for ideas than actually producing an OS (as you will see if you go through the mailing list archive).

Java has a relatively simple syntax compared to C or C++, is comprehensive in its libraries, is object-oriented, and runs on almost every operating environment a student might have. It is the perfect programming language for quite a bit of the foundational computer science courses.

Actually, Java has the syntax of C and C++. I see no difference.

If you want to see the perfect language for teaching CS, see Lisp or Scheme. Java has many pitfalls of its own*.

* Footnote: For a short review of Java see http://tunes.org/Review/Languages.html#Java.

Actually, if you want to play with a persistent programming environment, download a Smalltalk environment. Smalltalk environments are able to serialize themselves to image files. When subsequently re-serialized, the state of all the objects in the system at the time of serialization is restored.

Alan Bawden wrote a paper on it, and it's quite a good read. His web site has a compressed .gz version, but I found an HTML version of the HTML PCLSR Paper and I quote from its abstract here:

Under any timesharing operating system there will be occasions when a process must access the state of another process. A process may need to start, stop, debug, load, dump, create, or destroy another process. There is also one occasion when a process must access its own state: an interrupt handler needs access to the state of the running process prior to the arrival of the interrupt, so that the process may continue after the interrupt has been dealt with.

"PCLSRing" is a mechanism the ITS operating system uses to enforce a kind of modularity when a process must access the state of another process. The modularity principle is very simple: no process ever catches another process (including itself) in the act of executing a system call. System calls thus behave as if they were directly implemented in hardware. A process can no more catch another process in the middle of deleting a file than it can catch another process in the middle of a multiply instruction.

There was also a way to put the system into a PCLSR test mode that exercised all these control points within the system calls, to help debug them. See SYSDOC TEST documentation extracted from the now decomissioned AI PDP-10 that originally served it up as ftp://ftp.ai.mit.edu/pub/alan/its/sysdoc.tgz (yes, ITS was on the Arpanet and the Internet and ran TCP/IP as well).

The basic premise behind a microkernel is that device drivers will be black box proprietary binary code from untrusted third parties, hence require clumsy run-time protection. This hypothesis has been invalidated in practice for proprietary systems, and doesn't even make sense in theory for free software systems.

There is no need whatsoever for expansive memory protection between modules at runtime. Modularity is great, but at development-time, not runtime. HURD doesn't give you any additional development-time modularity; if anything, it removes it. If you want development-time modularity, drop that stupid C language, and use a modular language, such as Modula-3 (SPIN-OS), SML (Fox, Express), or Erlang (standalone Erlang).

Microkernels were the latest hype in the 1980's for OS development. They've only ever been hype, and it's sad that GNU people waste their time with such a stupid concept, whereas there's so much more to OS design, including lots of proven concepts, that just await to be implemented in free software (who's gonna implement the lost features from Genera? from Eumel?)

There is no right way to name your string hierarchy (i.e a file system).
Since there is no proper convention of attributing things such as title, content, author, etc. on the file (only type, in the extension), these are conviniently put in the file name.

The problem here is not spaces in file names, but the weakness of a string hierarchy.

File systems are dated technology (EROS Tunes...)

> Where is the substance to back the hype?

What hype? I have hardly even read about it here on Slashdot.

I don't see the point in Lindows because Wine could almost certainly do the same things and you would still have the power of X11/Unix alongside it.

Do you want the simplicity of Windows, not the power of X11/Unix? Sigh....

I want the simplicity and power of TUNES. Anything else (including X11/Unix) sucks.

You might not want to join my own TUNES project, that is mostly vapourware at the point; but you'll find there plenty of inspiration as to how the future of computing can be imagined. Then, it's up to you to revive the project, found your own, or evolve some existing project toward something you like better.

And of course, there's no reason why you should be victim of off-by-one bugs. There are already great languages with successful implementations that will rid you of them, and provide features undreamed of by people brainwashed with C/C++/Java. Clean, Common LISP (CMUCL), Erlang, Haskell, Mercury, ML (OCAML, SML/NJ, ML-Kit), Oz (mozart), Scheme (MzScheme), Smalltalk (Squeak), and so many more, are already available, and can enable kinds of hacking impossible with lesser languages.

Just don't you use inferior systems and then complain about the braindeadness. The only obstacle between your dreams and their implementation is YOU.

I think most of you, so far, are missing the idea here. I also think the good Dr. from IBM is too, but that is beside the point. The point here in redesigning the way systems work from the ground up is to make them more capable of doing what YOU as users/admins actually want them to do. The idea being that YOU set the policy and the computer learns how best to implement it.

I, personally, don't like this very much. It sounds like the next step in closing off the workings of the "operating system" from the user. What happens to Linux and open source when Windows starts to dynamically rearrange it's code to optimize for your preferences and specific uses? It gets left behind is what.

I've been thinking about where operating systems are headed and what I want in an operating system, lately. I had pretty much defined what I wanted, when I started to run across projects like this: TUNES, and ideas like this: Flow-Based Programming. I then realized that I wasn't entirely original. People have been thinking about the same things and trying to work them out for some time. But there has been little mainstream work done to get things to happen.

In my opinion, the design of TUNES and the ideas expressed about Flow-Based programming are a perfect fit for open source programming. And, there's no reason that autonomic computing couldn't fit right into the mix as well, as long as it's an open-source feature rather than a built in proprietary unified piece of the system.

The new system I'd like to see would be completely dynamically restructurable, and reprogrammable from the ground up. I think this would be a prerequisite for full-blown autonomic computing, but I have a feeling that the corporates are going to slip it into Windows in such a way that Windows stays the same on the surface, but just tells you less and makes more decisions for you than it already does. Problem is, that's what most users think they want. What I suggest is doing it in such a way that each user has total choice about how his system is designed and operated. Of course there would be predefined templates for certain types of systems (web servers, web/e-mail clients, gaming system, desktop publishing workstation, etc). So a user could pick one or more open source templates on which to base his system and then modify it to his needs as he goes. These templates would define what optimum scheduling and resource allocation should be done for specific tasks and merge this at the lower level with the needs of other tasks and the priorities set by the user or learned dynamically by the system.

I think we'll see some very interesting advances in the next 10-15 years. Let's hope the open-source community doesn't miss the boat. Microsoft sure as hell won't.

Come on guys, you've all seen Star Trek. Do you think the Enterprises computer system is much different? You don't see anyone in there with a PC.

Seriously, lets not confuse technobabble with real issues of OS performance. How does this design differ from a well-written distributed processing library? What advantages of speed will this give for applications like, say, QuakeIV^2?

What they describe sounds wonderful for a cluster of machines with very fast interconnects, working on very specific problems that are amenable to distributed processing, but ugly for 100,000,000 machines spread out to hell and back, engaged in 100M+1 tasks.

How about the TUNES project? Looks kind of similar, but with loftier goals.

I'm just not convinced I'd want the OS they describe. Doesn't solve any of my pressing problems.

I would say Enlightenment was the only (new) thing which could be considered innovation. It's mostly just eye-candy, but it does (did?) have various features which make it stand out from other window managers/desktops. Plus the speed was amazing for what it was doing (on slow X at that).

I must say this though.. innovation has been occuring in "open source" land since there was an "open source" land. It is just not as visible and usually not for people new to computers. From various languages such as CL, Scheme and Squeak (Smalltalk) to text editors (I don't recall seeing much syntax highlighting in Windows, but in Linux it is present in almost 9 out of 10 editors). I'd call some of the Linux kernel stuff innovation too (Reiser? file system).

The GIMP was to be a clone of Photoshop (or feature-wise the same). I don't recall Photoshop ever having something akin to Script-fu though (but I didn't use PS much so I could be wrong).

I see what you are getting at though. The problem with this whole desktop innovation issue (or better yet user interface) is it runs much deeper than the surface. It is incredibly hard to hide operating system and hardware design flaws with a fluffy GUI. No matter where KDE and GNOME go the underlying UNIX-like system will always be there with all of its design flaws "poking through" like weeds. Designing a new system (something like TUNES) is what really needs to happen, IMO.

Hence, I use A=65, B=66, C=67, etc...

I've called this encryption code "ASCII", which stands for "Absolutely Secret Code for Idiocy Interchange".

-- Faré @ TUNES.org

You can have multiple X servers running, one in each virtual terminal. I have a set of scripts that automatically launch a new X server with some minimal twm setting, so as to run applications full screen: view DVI/PS/PDF documents, JPG/GIF pictures, HTML documents with embedded pictures, play games, etc. Very handy when you're in a console switching period and your preferred window manager is the linux kernel's virtual terminal facility.

In case you don't want to roll your own from scratch, I can make my scripts available on request: they work very well for me, although it would require quite a lot of work to package them into a RPM, and you'll have to dig the CVS for versions that used to work with older X setups.

Unix sucks so much.

-- Faré @ TUNES.org

I think Paul Graham is tooting his own horn a bit too much here. Lisp was 35 years old when he used it in ViaWeb. His claim that "It was in fact the first big end-user application to be written in Lisp,which up till then had been used mostly in universities and research labs." is patently wrong. Has he forgotten about Emacs? When I was a lowly grad student, we used to work on Lisp Machines (a TI Explorer and a Symbolics Lisp machine). IIRC, their whole OS was written in Lisp.
So, for Mr. Graham to claim a first here is definitely hype.

Fare also wrote the vast majority of one of the vastest programming language comparisons I have seem. See The Language Review Subproject at Tunes.org.

And Tunes *has* produced at least one line of code...I think it was a prototype implementation of their programming language---Slate, I beleive.

• OCaml is multithreaded (linuxthreads was born as a way to get it to work on linux), although a single program won't take advantage of a multiprocessor. Core dump is impossible using its static strong typing, and the optimizing native-code compiler provides with great performance.
• JOCaml is an extension of OCaml based on the Join-Calculus, the latest and greatest paradigm for distributed programming (can be seen as actor-based programming done right, as based on a well-understood algebra). Can take advantage not only of multiprocessors, but of processor farms, or any distributed architecture, even heterogeneous architectures. Only bytecode can migrate, native code modules and primitives must be compiled into the servers.
• Erlang is based on a paradigm quite similar to jocaml, but is designed for industrial applicability rather than hacker coolness; it has dynamic typing, a pure functional core (despite the logic programming syntax, it only has matching, not unification), enriched with explicit asynchronous communication primitives, and an implementation that every phone call you make depends on, if you use British Telecom. If you need tens of thousands of threads and/or lots of nodes, this is what you need.
• There is also Mozart, an distributed implementation of Oz, a real logic programming language (has unification).
• Haskell and Mercury also have extensions for concurrent and distributed programming in the works, but I admit I don't know how usable they are for real programming.

-- Faré @ TUNES.org

I hope those toilets run a secure capabilites-b ased system like EROS or TUNES

The fact is, microkernels are a fraud , and the HURD, by embodying the advertised model, is both the victim and the accomplice of this fraud.

Conceptually, microkernels are an abstraction inversion: they force you to hand-implement run-time modularity using a non-modular low-level language, instead of auto-implementing modularity by compiling a modular high-level language into non-modular binary (see: SPIN, Fox, ML/OS, Squeak, and more).

Modularity is a source-level concept. Enforcing it at the binary level is DUMB and EVIL. Binary level should be efficient. Linux got it right (as far as a C kernel can).

If you want dynamically reconfigurable kernels, don't bother with HURD and microkernels, they do not provide any specific advantage for that that "monolithic" kernels don't have. If you really want dynamism, use dynamic languages (LISP, Smalltalk) or at least modular languages (Modula-3, SML, OCaml), not C.

BTW, VSTa is a free software microkernel that has actually worked for years, yet never attracted any specific interest: who cares how it works underneath? What matters is the high-level features it actually provides. In practice, nobody cares about the puny features provided by microkernels.

-- Faré @ TUNES.org

The fact is, microkernels are a fraud , and the HURD, by embodying the advertised model, is both the victim and the accomplice of this fraud.

Conceptually, microkernels are an abstraction inversion: they force you to hand-implement run-time modularity using a non-modular low-level language, instead of auto-implementing modularity by compiling a modular high-level language into non-modular binary (see: SPIN, Fox, ML/OS, Squeak, and more).

Modularity is a source-level concept. Enforcing it at the binary level is DUMB and EVIL. Binary level should be efficient. Linux got it right (as far as a C kernel can).

If you want dynamically reconfigurable kernels, don't bother with HURD and microkernels, they do not provide any specific advantage for that that "monolithic" kernels don't have. If you really want dynamism, use dynamic languages (LISP, Smalltalk) or at least modular languages (Modula-3, SML, OCaml), not C.

BTW, VSTa is a free software microkernel that has actually worked for years, yet never attracted any specific interest: who cares how it works underneath? What matters is the high-level features it actually provides. In practice, nobody cares about the puny features provided by microkernels.

-- Faré @ TUNES.org

Now the biggest problem with NS3 is lack of PNG inline-image support under Linux. There used to be a plugin, but it's no more available. Has anyone a binary copy? It looks like the sources are available somewhere, but recompiling them would require the reconstitution of a complete libc5 compile chain with many libraries: not an impossible task, but no small feat. Hum. Can anyone help?

Meanwhile, just a tip to prevent these nasty interferences between Netscape 3 and 4: edit your netscape 3 binary with emacs, and search&replace (ESC %) the string netscape with n3tscape. There you are. Don't forget to update your .Xdefaults accordingly.

-- Faré @ TUNES.org

-- Faré @ TUNES.org

[...] the fact that the U.S. government is a non-profit organization [...]

Uh? Who are you kidding? Looks like you have been smoking something fairly strong, lately (such as political propanganda).

"Non-profit organization": this term is such an oxymoron, anyway! As if any organization could last without somehow benefitting its members!

The whole DNS monopoly is a huge racket on the internet, anyway.

-- Faré @ TUNES.org

Now, the Evil premise in there is that anyone is entitled profits to begin with: who owes them any profit? If these industries are entitled the use of governmental force to keep or increase their profits, then so are customers! Customers have an interest in keeping and increasing the amount of cheap or free music, movie, information, etc, available to the public at large. Thus, the obvious move is to launch a class action suit as a counter-action, with every single real or potential customer of music, movie theater ticket, etc, sueing these industries for damages. Every single cent that was overcharged because of current monopolies can be claimed back as damage. Multiply $1000 of damages plus interest by 500 000 000 viewers worldwide, and destroy the robbers.

There has grown up in the minds of certain groups in this country the notion that because a man or a corporation has made a profit out of the public for a number of years, the government and the courts are charged with the duty of guaranteeing such profit in the future, even in the face of changing circumstances and contrary public interest. This strange doctrine is not supported by statute nor common law. Neither individuals nor corporations have any right to come into court and ask that the clock of history be stopped, or turned back, for their private benefit. That is all.

-- Robert A. Heinlein ("Life-Line")

-- Faré @ TUNES.org

Implementative power is what you can do with a program written in the language, once it's finished; if you're to produce closed-source stuff, that's the only thing you're interested in, and that's why people have been brainwashed by forty years of closed source into not caring about more than it. The language could be "write-only", and "write-once", implementative power wouldn't be less.

Expressive power is the information you can exchange using the language with other people with whom you work. When programming is an incremental undertaking, what you care about is expressive power. That's what people need in the world of free software computing. To be very expressive, the language must be "read-write" and "write-indefinitely".

For instance, a language to describe finite state machines operating on an indefinite tape (Turing Machines) can implement any one-shot computations from integers to integers in asymptotically optimal space and time. But as a tool for interprogrammer communication, it is not nearly as expressive as Cayenne that allows to describe arbitrary functions from arbitrary higher-order types to any other, including the ability to define statically enforced logical invariants. In Cayenne (which compiles into Haskell, which can be compiled into machine code, bypassing C for everything but for system interface and runtime support), you can define a type whose elements are precisely all sort functions, excluding any buggy function that sometimes fail. The language can thus express much more than C or any other implemented language, for that matter.

-- Faré @ TUNES.org

Want innovation? Have a look at the Tunes project.

Erlang (developped by the Swedish telecom company Ericsson) is an Open Source distributed operating system that runs on top of a host OS such as Unix or MS Windows. Erlang is based on high-level language paradigms, which makes it refreshingly different from all these C-based OSes. I think it deserves to be better known.

For a rather comprehensive list of operating systems, check out the OS review subproject of the Tunes project. Of course, since Tunes is The Ultimate OS, it is distributed also (its only disadvantage is that it (currently?) doesn't exist).

Erlang (developped by the Swedish telecom company Ericsson) is an Open Source distributed operating system that runs on top of a host OS such as Unix or MS Windows. Erlang is based on high-level language paradigms, which makes it refreshingly different from all these C-based OSes. I think it deserves to be better known.

For a rather comprehensive list of operating systems, check out the OS review subproject of the Tunes project. Of course, since Tunes is The Ultimate OS, it is distributed also (its only disadvantage is that it (currently?) doesn't exist).

-- Faré @ TUNES.org

Can I ask why text files with XML structure are not good enough?

Because it just pushes the burden of structure interpretation up to the application programmer. Ideally, when you're programming in a high-level language, you should be able to handle any objects in the system through a consistent set of primitives; the actual representation of your data on the computer should be implicit and left for the system to decide, unless the programmer himself specifies otherwise.

I see no reason why the Unix security model in particular cannot be extended to support safe, shared control of user applications.

The reason is that the Unix model (like most others today) is based on a "stupid" executive which, essentially, just goes around giving control to any piece of binary data which is tagged as "executable" and has the right headers (a.out or ELF). The web site for ETH Oberon goes into significant detail about an alternative executive model which is much smarter.

I think Sun calls that Java. :-)

Well, all of Java's essential flaws aside (and Ghod knows there are plenty of those :), I dare claim that an OS based on a Java VM would be far superior in all the aspects discussed here to our current crop of C/C++-based ones. (I'm not sure whether the JOS project for a Java-based OS is still going on... they seemed to have the right idea, kind of.)

??? Please elaborate.

You obviously weren't here the last time Slashdot had a "X sucks/X rocks" flamewar :) If you're interested, you can check the archives for the last two weeks or so. (Evidently, I stand on the "X sucks" side :)

After all, you can try all the variations you want, but you always end up with a flat cylinder for the wheel.

But that's already assuming that the software you started out to imitate is comparable to the wheel. Maybe it's not; maybe it's comparable to those squareish rock wheels you see on "The Flintstones" :)

And it's why we still use X11 and the WIMP model. They work well.

Well, "works well" is subject to discussion. IMAO, "works just barely well enough and it'd be a damned shame to start all over" is more fitting. And what you call "pragmatic", other people call "worse is better". (Then again, this kind of philosophy, "if it works, however barely, don't fix it", seems oddly fitting for a man who recently claimed that systems research was over. Again IMAO, that's akin to (Lord Kelvin's?) claim in the 1890s (less than two decades before Special Relativity and Bohr's atom) that essentially all of physics had been figured out, or to Hilbert's call in the 1900s (three decades before Gödel's Incompleteness Theorem) for a mechanic universal theorem decider.)

As for your comments regarding UIs (i.e., the part of the discussion which is actually on-topic :), I really think you should take a look at the unorthodox projects I mentioned in some other post. A look at Tunes' User Interfaces Review page should also prove interesting.

-- Faré @ TUNES.org

Since for obvious cost reasons, you'll most probably use IDE on your deployed machines, I recommend that your replicator be a mostly SCSI machine, with an IDE rack, and IDE compiled as kernel modules; this way, you can hot-plug and hot-unplug your IDE racked disks as you replicate them, by modprobing the IDE modules in and out (be sure to use the right hdparm/ioctl calls to flush caches and shutdown disks, though): no reboot needed!

Even without a SCSI machine, I've installed a company's computer rooms with IDE racks, and it's been a pleasure to replicate, install, test, fix, and reinstall machines there. (I also used debian as the basic distribution, which isn't perfect in a NFS- and NIS- sharing environment, but is the least horrible thing I tried.)

Finally, if your machines are heavily networked, you can use such thing as the Linbox Network Architecture (web site currently down for recreation; contact the people at linbox.com), which is basically a lots of diskless linux clients (you buy a fast ethernet and RAM instead of lame IDE disks), and a few badass servers for files and applications. Ten times less disks to maintain and clients without persistent state means much less administration.

Yours freely,

-- Faré @ TUNES.org

Corporations aren't moral entities.

Of course they are moral entities. Everything anyone chooses and does has moral implications. The only entities that are not moral are dead entities. Corporations are just groups of people. They can ignore their moral responsibilities; they can fail to be up to them; but they just cannot evade the fact that they are moral entities, the fact that their actions (or lack thereof) have moral implications.

Of course, in absence of the Rule of Law, a lot of big corporations have managed to become big because they behaved in immoral and unfair ways that ought to have been repressed but couldn't by a flaw of Law or of its Rule. But that's the problem with Legislation, Law and Liberty; it isn't in any way specific to corporations.

-- Faré @ TUNES.org