×

Welcome to the Slashdot Beta site -- learn more here. Use the link in the footer or click here to return to the Classic version of Slashdot.

Thank you!

Before you choose to head back to the Classic look of the site, we'd appreciate it if you share your thoughts on the Beta; your feedback is what drives our ongoing development.

Beta is different and we value you taking the time to try it out. Please take a look at the changes we've made in Beta and  learn more about it. Thanks for reading, and for making the site better!

Programming Languages Will Become OSes

michael posted more than 11 years ago | from the i-run-perl-OS-5 dept.

Programming 461

Anonymous Coward writes "A couple of months ago, at the Lightweight Languages Workshop 2002, Matthew Flat made a premise in his talk: Operating systems and programming languages are the same thing (at least 'mathematically speaking'). I find this interesting and has a lot of truth in it. Both OS and PL are platforms on which other programs run. Both are virtualizing machines. Both make it easier for people to write applications (by providing API, abstractions, frameworks, etc.)"

cancel ×
This is a preview of your comment

No Comment Title Entered

Anonymous Coward 1 minute ago

No Comment Entered

461 comments

FP! (-1, Offtopic)

Anonymous Coward | more than 11 years ago | (#5102811)

FP MUTHA F U C K A S !!!!!!!!!!!!!!!!!!!!

Hi there, my name is ralph. my name is ralph.
my name is ralph.

Slashdotted (0, Redundant)

Anonymous Coward | more than 11 years ago | (#5102812)

A couple of months ago, at the Lightweight Languages Workshop 2002 [http://ll2.ai.mit.edu/], Matthew Flat made a premise in his talk: Operating system and programming language are the same thing (at least "mathematically speaking"). I find this interesting and has a lot of truth in it. Both OS and PL are platforms on which other programs run. Both are virtualizing machines. Both make it easier for people to write applications (by providing API, abtractions, frameworks, etc.)

Intro, Isolation, Perl

The difference between the two, Matthew continued, is that OS focuses more on non-interference--or isolation between OS processes. The main task of a multiuser OS is to let several users use the computer simultaneously. Thus, it is important that no user can take over the machine or use up its resources permanently. Also, no processes shall be able to terminate other processes, peek into their resources, or do any other things that violate privacy unless it is permitted by the OS security policy.

On the other hand, PL focuses on expressiveness and cooperation. PL provides high level constructs and facilities so that one can write programs in less time and with less amount of effort. 10 lines of higher level PL code might be equivalent to 100 to 1000 lines of machine/lower level language code. Additionally, PL provides means for people to share reusable code through the concepts of modules, shared libraries, components, etc.

As time progresses, OS'es are becoming more like PL. And vice versa. OS now provides more and more ways for cooperation/sharing: IPC, threads, COM, etc. PL now provides ways to do isolation: sandboxing, processes, etc.

However, in all programming languages that I am currently using (Perl, Python, Ruby), none of them had been designed from the ground up to do isolation. Thus, none of the isolation mechanisms really work well.

This article will focus on above three languages. It would certainly be interesting to also discuss Scheme, Smalltalk, Java, and Erlang--however since I'm not adequately familiar with any of them I'll leave the readers to give feedback on these.

Why Isolation In PL?
As people construct more and more complex systems, the need for isolation becomes apparent. Complex systems usually untrusted user-level code that need to be restricted. Several examples follow.

Database systems usually provide some sort of stored procedure. A remote client can connect to the database and triggers stored procedure to be executed. It is important that if the stored procedure crashes or loops, other clients can continue to use the database.
Business applications usually allow users to specify business rules or constraints. Both are basically some simplified high level code. Users might specify these rules incorrectly and the application must ensure that those errors have any unwanted impact.
Web application servers usually allow pages/templates to contain code. Since generally the interpreter itself (e.g. Perl or PHP) is exposed to do the execution of the code, the application must somehow ensure that no templates can crash the application.
Other applications might allow users to specify regular expressions. Regular expressions is actually a language, though a mini one. Overly complex regexes--either specified accidentally or on purpose--can cause the regex engine to loop endlessly doing backtracking.
So, in essence, complex applications are usually a platform by itself, running subprocesses/subprograms (in a single OS process). Thus, this requires that the PL has isolation mechanisms beyond those provided by the OS: like restricting a piece of code from accessing a certain part of the filesystem, from using more than a specified amount of memory/CPU time, from accessing certain functions/modules/variables. Unfortunately, most PL don't have enough of them.

Perl
The two main security models in Perl are tainting and safe compartments. Tainting are mainly for tracing data, so I will not discuss it here.

In Perl 5.6/5.8 there are about 400 bytecode-level instructions, called opcodes. All Perl code will eventually be compiled to these opcodes. print is actually a single opcode. So are open, sysopen, mkdir, rmdir, fork, gethostbyname, etc. To see the complete list of Perl opcodes, see theOpcode documentation [http://search.cpan.org/author/JHI/perl-5.8.0/ext/ Opcode/Opcode.pm].

Two things are apparent. One, Perl opcodes are higher level than machine level instructions or even Java bytecode instructions. Two, Perl is a monolithic beast. Many facilities (like directory manipulation and even DNS-related stuffs) are built into the language. Perl5 is monolithic because of historical reasons. Perl6 will also be monolithic--so I heard--because of speed reasons.

Every single opcode can be enabled or disabled. This is done in the compilation step. If there is a forbidden opcode encountered by the compiler, the compiler will refuse it and compilation will fail. This has the advantage of speed: the cleansed code will absolutely have no run-time speed impact. The disadvantage: one must be careful to compile code at run-time--otherwise untrusted code can be compiled with dangerous opcodes in it.

The Safe.pm is a standard Perl module that allows a piece code to be compiled with a specified opcode mask (a list of opcodes that are to be forbidden). In addition to that, Safe.pm will do a "namespace chroot". It will make Safe::Root0 (or Safe::Root1 for the second compartment, and so on) as the code's main:: namespace. This means that the code in the compartment cannot access variables in the original main:: namespace, so global variables like $/ is not shared with code outside the compartment (Some variables like $_ or the _ filehandle is shared, though).

That's basically what Perl offers us for security. In practice, Safe.pm is not practical. Choosing a reasonable set of "safe" opcodes is not always straightforward. An opcode like open can range from "rather safe" to "extremely dangerous". Perl's open is so powerful and has many functions: it can open a file for reading, for writing, it can execute programs, open a pipe, duplicate a filehandle, etc. You can't, for instance, make Perl allow only read in open. Overriding open() doesn't make it safe, because the code in compartment can always refer to the builtin version using CORE::open(). Moreover, Perl can be told to read/write files without using any opcode at all (for example, using $^I). Thus it is not possible to restrict an unstrusted Perl code from accessing filesystem. To do this, one must resort to using OS facility (like Unix's chroot or BSD's jail).

The show-stopper for Safe.pm: most modules don't work under Safe.pm. DBI, for example. Embperl 1.x uses Safe.pm but drops it in the 2.x versions. Virtually no other web application servers uses Safe.pm these days. Even Perl experts say that Safe.pm is too broken.

Conclusion: Perl has some sort of sandbox, but it works at the compilation step only. It's not very flexible and it's not very useful. Perl is also monolithic and many functions are built into the interpreter. Thus, it is harder to isolate functionalities.

Python, Ruby, Conclusion

Python
The Python language design is very simple and clean. Amongst the security models of the three languages, Python's is the one I like the most. Python security model is capability-based, meaning that: if you don't want a certain code to be able to do stuff, you don't give a reference to the module/function that provide that stuff. Python is also much more modular: the core functionality is much less than that of Perl. For example, OS specific services--like unlink or rmdir--are located in the sys and os module. This means we can more easily restrict access to those services by depriving the code from importing the appropriate modules.

Here's Python's execution model: each code runs in a frame ("a context"). In a frame, there are two namespaces: the local and the global namespace. A namespace is a mapping between names and objects. You get reference (=capability) to objects from a namespace. Every time a variable/function/object/module name is mentioned, Python will look for it in the namespaces. The local namespace will be searched first, then the global. If the name is not found in either, Python will give a NameError exception.

We can manipulate a namespace easily, since it is available as a dictionary. We can even execute a code and give it our custom dictionaries to be used as the code's local and global namespaces. This way, we can limit what objects are available to the code. That's basically how the security model works in Python.

Actually, there's a third namespace that will be searched when a name is not found in a local and global namespace: the builtin namespace. The builtin namespace contains basic functions like open, exit, execfile. Most of the Python's builtin capabilities are provided through this builtin namespace. The rest is creatures like print or exec which are statements, not functions/objects.

rexec is the standard Python module to do sandboxing. It basically does what is explained above: run the sanboxed code with a custom local and global namespace. Additionally, rexec creates a custom builtin namespace and provides a safer substitutes for functions like open or __import__. This way, we can tell rexec to forbid the untrusted code from opening a file in write mode. Or from importing dangerous modules.

rexec is pretty flexible and indeed has been used successfully in several applications. Guido's web browser Grail, for instance, allows running Python applets. However, rexec seems to be not flexible or fine-grained enough, because Zope chooses not to use rexec. Instead, it uses its own home-growned module to do restricted execution.

There are several things that rexec can't do. Resource limiting, for example. To do that you need to resort to the OS (like using Unix's setrlimit). Also, since Python does not have private attributes, you can't give an object to an untrusted code without the fear that the code will use the Python reflection mechanism to "peek into the guts" of your object (and from there gain references to other objects). There are two separate solutions to the last problem: the Bastion and mxProxy C extension modules, which essentially provide private attributes.

Conclusion: Python has a nice and simple security model. However, rexec cannot do all kinds of isolation that one might need, like resource limiting. Guido once also said that rexec is not tested enough and it might contain security holes.

Ruby
One of the main goals of Ruby seems to be "to replace Perl". In that respect, it has copied many Perl features. Tainting is one of them. In Perl there are two running modes: tainting mode on (-T, setuid) and off (no -T). Ruby extends this concept a bit by providing four different "safe levels" (indicated by the global variable $SAFE). The different safe levels is as follows.

Safe level 0 (default mode): no tainting is performed.

Safe level 1: tainted data cannot be used to do potentially dangerous.

Safe level 2: in addition to level 1 restriction, program files cannot be loaded from a globally writable locations (e.g. from /tmp).

Safe level 3: in addition to level 2 restriction, all newly created objects are considered tainted.

Safe level 4: in addition to level 3 restriction, the running program is effectively partitioned in two. Nontainted objects may not be modified. Typically, this will be used to create a sandbox: the program sets up an environment using a lower $SAFE level, then resets $SAFE to 4 to prevent subsequent changes to that environment.

It's evident that, as with tainting, the safe levels are primarily concerned with data security and are not very sandbox-like (in the sense of "isolating subprocesses from another" sandbox). Matz confirmed this in the ruby-talk mailing list by saying that Ruby currently does not have any sandbox yet. Running a code in safe level 4 is usually too restrictive to be practical, plus it does not provide enough isolation.

The problem with isolation in Ruby is that all objects are accessible from any code through the ObjectSpace facility (including the code running in safe level 4). This is of course in direct conflict with the capability concept, in that you don't give a reference/capability unless necessary. However, Ruby does protect an object's attributes and has a #freeze method to make an object becomes read-only.

Conclusion: Ruby doesn't have a sandbox (yet).

Other PL's
Java has a sandbox security model and a bytecode verifier. Tcl basically has the same. Erlang is evolutionary more advanced in providing isolation, in that it has a notion of "PL-level processes" (a process is isolated in all ways from another).

Conclusion
As people construct more and more complex applications in PL, PL's are required to have adequate security/isolation mechanisms. Current PL's in mainstream usage do not have adequate security mechanisms, so programmers are often forced to fall back to using facilities provided by the OS. This has drawbacks such as lack of portability and reduced efficiency. There will perhaps be new PL's designed with isolation as one of their main goals--or current PL's might be improved/redesigned--so hopefully this requirement of having a "multiuser PL" will be fulfilled in the future.

About the Author:
Steven is a software developer residing in Bandung, Indonesia.

Re:Smalltalk as OS (5, Insightful)

tpr (267368) | more than 11 years ago | (#5103004)

It so happens that I know a bit about Smalltalk so perhaps I can help a little.
Smalltalk was originally the entire system on the original hardware. Indeed, Dan Ingalls said back then (paraphrasing, I don't have the exact quote handy) "An operating system is a collection of things that don't fit into a programming language. There shouldn't be one".
The reality of commercial machines caused those of us interested in using Smalltalk to accept the limitations (and it must be said, benefits) of OSs. Even so, there have been several occasions where an attempt has be made to use Smalltalk as the entire system: the Active Book and the Momenta machines for example and more recently the Interval Research MediaPad (where the RTOS was written in Smalltalk).

These days I'd be inclined to 'soften' Dan's statement to something like "An OS is a collection of things underneath the language. There shouldn't be any way to tell the difference". That is to say, the language ought to be able to make full use of anything available without having to burden the programmer with wierd crap.

Re:Slashdotted (0)

Anonymous Coward | more than 11 years ago | (#5103008)

Who is the idiot who moded up this??? Please mod it down. The site is NOT slashdotted, works just fine for me.

well yeah (-1)

Anonymous Coward | more than 11 years ago | (#5102814)

its all 1's and 0's

FP

Lisp (0, Informative)

Anonymous Coward | more than 11 years ago | (#5102815)

Seems to me that this is old hat. Lisp has been an OS since the 60's. We just don't feel the need (often) to call it that.

Re:Lisp (1, Informative)

Anonymous Coward | more than 11 years ago | (#5102897)

I use Lisp frequently. It is not an OS. It is an interpreter. There is a huge difference. If still not convinced, take a look at the source for GCL and the Linux kernel.

Re:Lisp (2, Informative)

Anonymous Coward | more than 11 years ago | (#5103048)

Don't spread misinformation. Lisp is often interpreted, but in production use it is always compiled. GCL, for instance, is most assuredly a compiler.

The point is not that the code to a Lisp compiler is anything like the code to an operating system; rather, it is that each advanced programming language provides its own set of high-level abstractions for what are traditionally OS-level services.

Re:Lisp (0)

Anonymous Coward | more than 11 years ago | (#5103090)

Fine, GCL is an interpreter\compiler. That issue was important in the 60's and 70's, but not anymore.

The "point" is that an OS must have code to communicate with the BIOS, hard drive, memory managament, optimization of the use of registers, ...

A programming language is a specification of how code should be interpreted\compiled and an implementation of that specification interprets\compiles the code, hopefully, according to the spefication. The Lisp language does not include code on how to deal with AMIBios or a Pentium IV processor!

Huh? (Was Re:Lisp) (0)

Anonymous Coward | more than 11 years ago | (#5103012)

Does Common Lisp handle security? No.
Does Common Lisp handle network connections? No.

Please tell me how Lisp is an OS.

Re:Lisp (1)

Raiford (599622) | more than 11 years ago | (#5103082)

Although there are Lisp OS projects past and maybe present, LISP OSs aren't prevelent. You may be thinking about LISP machines [faqs.org] which are designed specially to run LISP programs and provide an optimized environment for LISP development.

First Post (-1, Offtopic)

Anonymous Coward | more than 11 years ago | (#5102817)

Ha! Ha!

Programming languages become OSes? (5, Funny)

Anonymous Coward | more than 11 years ago | (#5102818)

Already happened: Microsoft BASIC ==> Microsoft Windows

Re:Programming languages become OSes? (4, Interesting)

RetroGeek (206522) | more than 11 years ago | (#5103050)

You are closer to the truth that you suspect.

The original IBM PC's would start up with ROM BASIC if no other OS was present.

Emacs! (0, Interesting)

Anonymous Coward | more than 11 years ago | (#5102819)

Emacs is Emacs Lisp.
Emacs is an Operating System.
Emacs Lisp is an Operating System.

QED

Re:Emacs! (1, Funny)

ketamine-bp (586203) | more than 11 years ago | (#5103017)

Just to elaborate (and make it funnier.)

Emacs is Emacs Lisp.

If Emacs = Emacs Lisp, either that Lisp is 1 (universal truth) or Emacs is 0 (universally untrue).

Hence, this statement is somehow applicable to both vi zealots and emacs zealots, and should not be considered Emacs-speak ;-) (supporters alike - i prefer no flames on this matter, please.)

Oberon anybody? (5, Informative)

sofist (556213) | more than 11 years ago | (#5102821)

Just remember the past. Oberon was an OS an a PL at the same time and I think most of the readers didn't ever heard about it...

Re:Oberon anybody? (4, Informative)

CoolVibe (11466) | more than 11 years ago | (#5102873)

Oberon? Smalltalk! Now there's something you could turn into an OS.

Although, Oberon is not the past. It's still being actively developed, in both it's OS and PL incarnation.

TRS-80 (2, Interesting)

Anonymous Coward | more than 11 years ago | (#5102823)

my TRS-80 had BASIC as the OS

Well I think.... (0)

Anonymous Coward | more than 11 years ago | (#5102824)

mozilla has proved how sucessful that approach is.

Re:Well I think.... (2, Funny)

captain_craptacular (580116) | more than 11 years ago | (#5102875)

Gee, I didn't realize mozilla was a programming language. I'm going to go now and arrange my tabs into a lexographic sequence and get them to do something new, maybe say hello world.

Re:Well I think.... (-1)

Anonymous Coward | more than 11 years ago | (#5103059)

Mozilla is a development platform you dumb cunt, and I was being sarcastic. Go die of cancer.

Slashdot and Homosexuality are the same thing (-1, Flamebait)

Anonymous Coward | more than 11 years ago | (#5102829)

Slashdot and Homosexuality are the same thing (mathematically speaking at least).

Re:Slashdot and Homosexuality are the same thing (-1, Flamebait)

ddriver (613483) | more than 11 years ago | (#5103042)

Thats kind of funny because you are posting to /. ... what does that make you?

Use Emacs (4, Funny)

aridhol (112307) | more than 11 years ago | (#5102832)

If you use Emacs, you have a programming language, OS, and editor all in one happy package.

Re:Use Emacs (0)

Anonymous Coward | more than 11 years ago | (#5102893)

I've always felt that Emacs is an editor, a programming language, an operating system and a religion. I've been using it almost every day for 14 or so years. There is not much else that I can talk about in a family newspaper that I've been doing as regularly . . .

Re:Use Emacs (0)

Anonymous Coward | more than 11 years ago | (#5102923)

I bet the right-hand side of your keyboard knows what you've been doing (unless you're left-handed). The springs on the keys on that side get compressed more because your right hand is stronger from all the vigorous excercise.

Re:Use Emacs (5, Funny)

bperkins (12056) | more than 11 years ago | (#5102992)

Found in someone's sig file:

Emacs: It's a nice OS, but to compete with
Linux or Windows it needs a better text
editor. - Alexander Duscheleit

Re:Use Emacs (0)

Anonymous Coward | more than 11 years ago | (#5103023)

or Mozilla for that matter...

Happened before... (4, Insightful)

meringuoid (568297) | more than 11 years ago | (#5102833)

... the home computers of the early '80s didn't really have OSes, they had programming languages. You'd boot a BBC Micro and it would fire up into BBC Basic - with a few * commands for file system manipulation. Or you'd boot a Spectrum and you'd get the same: the name of the system and a prompt to begin typing your program.

Re:Happened before... (4, Interesting)

Transient0 (175617) | more than 11 years ago | (#5102972)

Yes, and interestingly, the article isn't even really saying that OSes and programming languages are the same thing. What it is saying is that any programming language worth it's salt has the potential to become an OS and that it will probable eventually do so for security reasons. Then he tacks on "There will perhaps be new PL's designed with isolation as one of their main goals--or current PL's might be improved/redesigned--so hopefully this requirement of having a 'multiuser PL' will be fulfilled in the future." as his last line.

The bulk of his argument is sound and has convincing precedent in the examples you give(Micro, Spectrum, etc.) and I could add a few of my own, not to mention the modern example of Java. As for his ad hoc specualtion at the end that programming languages will eventually replace OSes. I'm prepared to call that bullshit until he presents some evidence. I don't see it happening, who wants to code on a machine that can only use one language?

Of course, the response is that new language will be written to run inside the OS-Language and that coders can work in either these sub-languages or the OS-level meta-language. But really how would this be any different than the current situation with many languages vs. assembler as meta-language only with an additional obfuscating level of go-between.

my two cents.

Well, C++ is a very insecure "OS" then... (0)

Carp(310) (641771) | more than 11 years ago | (#5102989)

Obviously, I think most of us with a reasonable schooling in software would agree that applications written in C++ are the biggest security threat for PCs today. This is why you've been seeing more and more Java based applications on the PC lately. Most of the C++ vulnerability comes from a single, well known, and often exploited bug in the Windows C++ virtual machine. This bug allows C++ programmers to access protected and private data that is SUPPOSED to be secured by the C++ virtual machine. Here's a simple example of a crack that would allow a C++ programmer to access improperly secured data:

Let's say we have this class called PersonalFinances:
Class PersonalFinances
{
private:
char creditCardNumber[16];
};

To bypass the Windows C++ security manager, all we need to do is write some code like this:
Main( )
{
PersonalFinances finances; // Forge a pointer to peek inside the class
char *cardno = (char*)
printf("Stolen credit card number = %s\n", cardno);
}

Simple as that... we have stolen "secure" data. Curiously enough, this code sample came from O'Reilly's "Learning Java" book. This book was first printed in 2000, which means that this critical security bug has been known for over 3 years! I find it quite unbelievable that this lack of response (from Microsoft) is tolerated in the software community. Why haven't they responded? Simple... MONEY. Rather than maintain old code, Microsoft would rather push their new .Net framework as a new standard and make big cash off of its widespread adoption. Another way that MS will profit from this security hole is by pushing their dreaded Palladium scheme on us. Palladium, put simply, is just a hardware solution for this exact sort of security issue. Meanwhile, we consumers sacrifice our privacy through insecure software so Microsoft, Intel, and AMD can reap big profits sometime in the future.

If you are fed up with these monopolistic profit schemes, this is what you do. Start or support an open source Windows C++ virtual machine project. A port from the Linux VM should be possible.

We DEMAND better protection of our privacy!!!

Ridiculous (1, Troll)

PhysicsGenius (565228) | more than 11 years ago | (#5102835)

The operating system is the "government" of the computer. (It's a totalitarian dictatorship, but still.). Programming languages are...languages. Would you say that "English and Democracy are practically the same thing, look there's an English word for 'vote'!"

Whoever gave this talk needs to go back to CS 101.

Re:Ridiculous (0)

Anonymous Coward | more than 11 years ago | (#5102964)

Your analogy is very loose and hardly detracts from the article. Maybe if you could explain why the relationship between a government and a natural language like english is the same as the relationship between an operating system and a programming language, it would make more sense. Ever heard the term "mixed metaphor?" Just because an OS is like a government in some sense, and a programming language is like a natural language in some sense, doesn't mean that when you put the two metaphors together the relationship is also analogous.

Re:Punch Card Systems (1)

VoidEngineer (633446) | more than 11 years ago | (#5103062)

Hmmm. Well, harking back to days of yore, I recall that punchcards were the basic in/out system of computers.

I suppose that one could look at the article at hand in terms of whether or not punch cards contain linguistical features (language support) or systemic features (operations support).

As such, I'm not all that sure that the method of transfering information from a punch card was/is the same as decision making operations utilized by the machine itself.

Call me crazy, if you will, but it seems to be a text/context dichotomy to me, where one cannot have a PL without an OS, and vice versa. That is, they go hand-in-hand, and each are somewhat inherrent in the definition of the other.

But I'm no computer scientist... =)

Really? (4, Insightful)

teetam (584150) | more than 11 years ago | (#5102839)

While this may be conceptually true, there are different considerations involved when picking an OS and a language. A programming language is more like a tool that is selected because it is good for a particular operation.

A single machine could have multiple languages co-existing for different tasks. Some of these tasks require quick and dirty scripting, some require high performance and some other application programs might concentrate on object oriented features and such.

The operating system, on the other hand, is typically only one per machine and performance and stability might be the major considerations (other than compatibility with the popular applications around!)

Re:Really? (1)

Kynde (324134) | more than 11 years ago | (#5103091)

While this may be conceptually true, there are different considerations involved when picking an OS and a language. A programming language is more like a tool that is selected because it is good for a particular operation.

The operating system, on the other hand, is typically only one per machine and performance and stability might be the major considerations (other than compatibility with the popular applications around!)

I disagree with you there, and I think you didn't think that through yourself. Currently mainstream OSs are designed and optimized for common case. But as we already see, we have demands like Real Time, high throughput and good interactivity that aren't really met by main-stream OS.

A lot of people have been asking that such decisions would be left tunable in linux for example. Last fall during the quest for high throughput and all those db benchmarks resulted in extremely POOR desktop feel. Software compilation in another window jammed your editor for example, which for a desktop developer is something you never want to be face to face with. Even now the only way to achieve good feel with 2.4 is to buy more memory and turn off swap all together.
Naturally that nullifies all the benefits that the "clever" mm does for throughput in linux.
(for the record 2.5 behave a lot better)

In any case the language selection like you said is alread taking place also with OSes. Neither Linux nor Windows is suitable for hard real time for example.

Add the Hardware component ... (0)

Anonymous Coward | more than 11 years ago | (#5102841)

And you have a Lisp Machine.

All mathematically the same!

Hmmmmm.

Re:Add the Hardware component ... (0)

Anonymous Coward | more than 11 years ago | (#5102869)

Or even a Turing Machine...

But as for a "multiuser PL" - sounds like a recipe for disaster (conversely, do I want to check out my disk space in order to save to it?)

Amusing... (1)

j_kenpo (571930) | more than 11 years ago | (#5102842)

This is funny. This exact thing appeared on OSNews earlier this week... and was promptly followed by an unrelated article entitled "Future of Operating Systems: Simplicity". So which is it, simplicity or programming?

Well, duh. (1)

AsOldAsFortran (565087) | more than 11 years ago | (#5102848)

Bill Gates and company figured this out when Java was released. This article is much more interesting that that simple observation, though.

Posted on osnews.com several days ago. (-1, Offtopic)

Anonymous Coward | more than 11 years ago | (#5102850)

...so no news here. *moving along*

Offtopic? You bloody moderators. (0)

Anonymous Coward | more than 11 years ago | (#5102939)

Yep. The bare truth!

SHORTEST AND LONGEST BOOKS EVER WRITTEN (-1, Offtopic)

Anonymous Coward | more than 11 years ago | (#5102855)



SHORTEST BOOKS EVER WRITTEN

"A Guide To Arab Democracies"
"A Hiker's Guide To The Ho Chi Minh Trail"
"Advanced Linux User's Guide"
"Blacks I Met While Yachting"
"Career Opportunities for Liberal Arts Majors"
"Excellence In The CFL"
"Fast And Efficient Windows Applications"
"How To Be A Good Sport", by Tonya Harding
"How To Win The Super Bowl", by Jim Kelly
"Keebler Elves That Touch Themselves"
"My Life As A Woman", by Martina Navratilova
"The Engineer's Guide to Fashion"
"Young, Single Males Speak Out Against Masturbation"
"How to be Normal" and "How to be Polite" both by RMS
"Easy to use Linux"
A Canadian telephone book
"My Social Life" by ESR
"Correct Spelling and Grammar in English" by Rob "CmdrTaco" Malda
"Business Ethics" by William Gates III (with foreword by Ken Lay)
"Heterosexuality among the Slashdot crew"
"Truths I have told" by Al Gore
"How to Speak Clearly and Correctly" by George W. Bush
"How Canadians Stand Up for Themselves"
"How to Get a Date with a Woman" by your local LUG
"How to Tell the Truth" by William J. Clinton
"The Names of Women Interested in Linux Geeks"
"Successful Business Plans Using Linux"
"What I Wouldn't Do For Money" by Jon Katz
"How to Write Software People Would Want to Buy" by Linus Torvalds
"Addresses of Houses in Canada that aren't Igloos"

LONGEST BOOKS EVER WRITTEN

"Loneliness, Buttplugs, Linux and You" by ESR
"Why your name should have 'GNU/' in Front of It" by RMS
"Being Rude to Foriegners" by the French Government
"How to Sexually Abuse Penguins" by Linus Torvalds
"Homosexuality among the Slashdot crew"
"How to Look Like a Cave Dwelling Communist" by RMS

Re:SHORTEST AND LONGEST BOOKS EVER WRITTEN (0)

Anonymous Coward | more than 11 years ago | (#5102946)

What are you talking about? The Slashodot crew any you only wish you guys were gay. Gay people are so much cooler. ;)

Behind the times? (3, Informative)

Mordant (138460) | more than 11 years ago | (#5102856)

I guess Mr. Flat (what a name!) hasn't ever heard of the LISP Machine. [uni-hamburg.de].

Lisp Machine's Language (Was Re:Behind the times?) (0)

Anonymous Coward | more than 11 years ago | (#5103057)

Did you know that there were parts of the Lisp Machine kernel that were not written in Lisp? Small sections were written in assembly.

great... (1)

jpsst34 (582349) | more than 11 years ago | (#5102863)

Programming Languages become one and the same as Operating Systems. Then Microsoft will come out with "FrontPane," the WYSIWYG OS editor that allows everybody and their brother to create shitty OS interfaces inside of an editor, while writing autrocious code "behing the scenes."

Shittier than Luna, that is...

Intent (Was Re:great...) (0)

Anonymous Coward | more than 11 years ago | (#5103083)

Was your intent to sound crazy or stupid?

Chicken Before the Egg? (0)

Anonymous Coward | more than 11 years ago | (#5102876)

Historicaly, which come first ? Operating system or PL ?

Re:Chicken Before the Egg? (0)

Anonymous Coward | more than 11 years ago | (#5102986)

Programming languages, or at least machine code as a programming language, though not many people could program a computer that way.

I hate to be a killjoy... (0)

Anonymous Coward | more than 11 years ago | (#5102879)

But this idea has been around a long time. Remember the plethora of 8-bit computers back in the 80's that "booted" to BASIC?

Can you say C-64 redux?

Bah (3, Insightful)

p3d0 (42270) | more than 11 years ago | (#5102883)

That's like saying doctors and scalpels are really the same thing because they both perform surgeries.

OSes and programming languages have some superficial features in common, but they are totally different concepts. This is so manifestly obvious that I'm not even sure how to argue the point.

However, Mr. Flat's suggestion that languages need better isolation capabilities is a good one. It all goes back to Fred Brooks' point that one in ten programmers is a superstar. I think isolation facilities in a programming language allow the superstar to set the rules that the other nine programmers must follow, making the system more coherent by the guidance of one mind.

Isolation capabilities... (1, Insightful)

MosesJones (55544) | more than 11 years ago | (#5103086)


So what Mr Flat is really saying is that he hasn't looked at Eiffel, Ada, OCL or any design by contract work.

This really is a bizarre article that most first year students would get marked down for.

FORTH (4, Interesting)

turgid (580780) | more than 11 years ago | (#5102884)

FORTH was and still is such a combination. It's compact, easy to implement and incredibly fast and felxible.

Re:FORTH (0)

Anonymous Coward | more than 11 years ago | (#5103085)

Look at colorForth [colorforth.com] for a modern conception of FORTH; from the original creator of FORTH, Chuck Moore.

That's why MS is so afraid of Java (3, Insightful)

rmayes100 (521535) | more than 11 years ago | (#5102886)

Microsoft is always pretty quick to recognize new products that could threaten windows dominance. In some ways platform independent languages (most scripting languages, Smalltalk, Java) already implement their own OS on top of the OS they're already running on.

Why, yes, this was what I was missing all along! (1, Funny)

NetRanger (5584) | more than 11 years ago | (#5102891)

This astute piece of observation has made me become far more transcendental. Now I realize that we're all just connected.

Yet I shall take this wisdom even further: the digital universe is based upon everything being opposite, where you have everything and nothing.

That's deep, man.

Re:Why, yes, this was what I was missing all along (0, Funny)

k98sven (324383) | more than 11 years ago | (#5103055)

To paraphrase "the tao of programming":

"I don't know whether I am an operating system dreaming that I am a programming language,
or a programming language dreaming that I am an operating system!"

don't think so (3, Insightful)

jacquesm (154384) | more than 11 years ago | (#5102905)

This is *not* going to happen.
For one the wall between OS space and user space is there for a good reason (security) and second different people like to use different languages, and you'll lose a good part of your developers by forcing them into the straightjacket of a single language for a certain os.


it's been tried before (smalltalk, java) and failed, for these and a whole bunch of other reasons.

Re:don't think so (0)

Anonymous Coward | more than 11 years ago | (#5103075)

It IS already happening. There already exists a raw port of Squeak (Smalltalk-80 derivative) that runs on raw hardware, with no other "operating system". Ditto for Oberon.

As for the straitjacket, why do you believe this would force you to use one language? What's to stop someone from implimenting a C compiler in Smalltalk or Java? Or any other language for that matter.

Isolation (1)

Gimpin (595657) | more than 11 years ago | (#5102915)

...chroot should do the job for all you evil buffer-overflow script kiddies out there

Idealism (3, Insightful)

PourYourselfSomeTea (611000) | more than 11 years ago | (#5102918)

Actually you see this reflected in modern systems designs such as Cocoa/OC or Java. They are in themselves virtualized operating systems. Adding classes in these adds reusable functionality to the overall system, much like adding functions in Lisp adds functionality to the system.

This is especially true of the VM languages (3, Interesting)

UpLateDrinkingCoffee (605179) | more than 11 years ago | (#5102922)

Like java... I think a likely evolution will be towards a single VM that runs all your programs instead of the one VM per app generally used now. More and more of the process switching and memory management will be built into the VM's probably to the point one day where java VM's become operating systems in their own right and only need the underlying OS for drivers to talk to the hardware.

The 2008 Operating System Review (3, Funny)

wackybrit (321117) | more than 11 years ago | (#5102928)

In the future, when all programming languages will become operating systems, there'll be a lot of competition. Choose the operating system that works the best for you:

C OS - Every single task you want to achieve has to be split into fifty bite size actions.

COBOL OS - The literati's dream OS! No longer must you click and drag, but instead type bizarrely syntaxed English to do your work! PROGRAM OPEN CALCULATOR AS NEW PROGRAM

Perl OS - An open source OS worked on by a bunch of extremely crazy (but clever) bearded anoraks. You can do EVERYTHING in one click or one line of code. Oh, face it, it's just the future of Linux.

PHP OS - This OS was originally the shell for Perl OS, but some wimps who couldn't work out the Perl way of doing things decided to turn it into their own 'paint by numbers' OS. Unfortunately you can only access the Internet with PHP OS, no off-line facilities are available.

C++ OS - A simple upgrade to C OS. Still just as complicated, but the ++ makes it cooler to use and adds a host of useless features that are non standard across all implementations. Besides, C OS is for old fogeys.

Python OS - Supposedly this exists, but since no-one cares, we won't go into it.

Ruby OS - EVERYTHING is an object. Want to open your calculator app? calculator.open; please. Need to enter some numbers? calculator.buttons[8].press; It's long, tedious, but at least it makes logical sense.

BASIC OS - Joe six pack's answer to operating systems. This is Microsoft XP in the future. Anything can be done with point and click, but it's slow, crashes a lot, and is totally lame. Oh, I'm already talking about XP here aren't I?

Funny he did not mention .NET (3, Interesting)

watzinaneihm (627119) | more than 11 years ago | (#5102930)

If any programming language/framework has a chance it will become an OS it is .NET.
And Java is half an OS already, it has its own threading moodel, has memory management etc. Though frankly I believe this paradigm of PLs becoming OSes will be first be seen on handhelds etc. Note that many Cellphones run Java etc. (though now sybian is more commoon).

Sounds familiar (1)

Amsterdam Vallon (639622) | more than 11 years ago | (#5102942)

Plot: In the year 2003, the technologically-starved masses depend upon the United States government-manufactured item Microsoft Windows to exist and manage their day to day activities. But in the midst of an investigation, a hacker uncovers the chilling source of the product...

Microsoft Basic is Microsoft Windows!
*louder*
Microsoft Basic is Microsoft Windows!
*shouting at top of lungs*
Microsoft Basic is Microsoft Windows!

It naturally follows. (1)

ketamine-bp (586203) | more than 11 years ago | (#5102951)

When it was ENIAC, somebody wires. Then somebody even wiser put that 'wiring part' into solid-state, electronic controlled one. That's the 'machine code'.

Then, it is the punch card era, and then somebody think it is better to write words other than bunches of 1 and 0's, hence, we have assembly language, and it comes with the operating system.

After that, somebody thinks that writing assembly language is too cumblesome and too hard to learn for some people, for example, your workmate and me, then, higher-level languages like C and FORTRAN arrives, and it comes with the operating system, yet, machine-code level tools no longer comes with the majority of the machines.

Then, when it is the year that most of the users isn't programmer, the programmer make the computer comes with programs that let you select task rather than instructions to do things, and results in 'shells' or 'command.com' (for win'ies.), it comes with the OS at that point, and programming tools are disappearing from the original package.

When it was the year that too many computer illiteracies want to learn and use computer, yet some wise men write programs that allow a user to use a mouse to click on somewhere to do some job, and hence it comes to the GUI era, and it is shipped with computer, computer no longer comes with command-line tools.

Now that the people are way too lazy to do the job even with assistance with the computer, they actually want the comptuer to do it for themselves, some eventually somebody wise enough will develop a system that allows the user to key-in the objective and the computer will automagically do it.

Don't see the analogy?

Every operating system is just some sort of translator that translate your use of language (e.g. BASH command) into machine readable thing. however, note that the above sequence need not be step-by-step completed, i.e. it may go something like this:
User command --> C program --> Machine code instruction.

In general, though:

MACHINE CODE <-- computer level
ASSEMBLY LANGUAGE <-- (e.g. AT&T assembly)
STRUCTURAL PROCEDURAL LANGUAGE (e.g. Pascal)
SCRIPTING LANGUAGE (e.g. PERL)
COMMAND-TYPE LANGUAGE (e.g. SQL)
POINT AND CLICK (e.g. X, MacOS, etc.)
DESCRIPTIVE (Natural human language, e.g. English)

Correct me if I'm wrong, follow-ups welcome.

For fuck sakes (0)

cp5i6 (544080) | more than 11 years ago | (#5102954)

Read the previous message people.. LISP/EMACS has been mentioned over 300 times.
How can you NOT see that someone else already posted some shit already..

This is supposed to be a fucken discussion not "blalblab LISP.. blalbla EMACS"

talk about USEFUL things... I dunno like if an OS was built around perl and discuss how easy it would be to setup yer various unix jobs. Or if every form of data on your computer was saved to XML instead of all the propietary file formats nowadays.

or if every program on yer computer was all written in one language including the OS itself.. I dunno wahtever...
but make it a fucken interesting discussion instead of Lisp or EMACs does this.
if you wish to talk about LISP or EMACS... whip out the technical docs and fucken tell me all the system hooks that LISP or EMACS uses in it's VMs to qualify it as an OS.

Sure, the distinction is artificial/arbitrary... (4, Interesting)

dpbsmith (263124) | more than 11 years ago | (#5102956)

...the partitioning of computer environments into applications, OS, "drivers," "libraries," etc. etc. is arbitrary, cultural, traditional, etc. To some extent it's also based on modularity considerations, and to some extent on marketing/commercial considerations. There's no fundamental logic to "the way things are."

A few decades ago, MANY environments blurred the distinction between OS and language: FORTH, MUMPS, SMALLTALK, and, indeed, most early versions of BASIC, to name four.

The traditional textbook discussion of an OS ("provides four interfaces, to the filesystem, to devices, to applications, and to users") is just a discussion of what IBM evolved in the sixties or thereabouts.

Incidentally, the very name "operating system" indicates the original rationale and function of these pieces of software. They were intended to automate the functions that previously required the manual services of an "operator," thus increasing utilization and decreasing payroll.

Another example of the arbitrariness of the term "OS" is the way in which various applications programs are now considered to somehow be part of the OS. In Digital's glory days, these were sometimes referred to as "CUSPS"--Commonly Used System Programs. Is grep "part" of UNIX? Is Windows Explorer (not Internet Explorer, but Windows Explorer--the application that displays directory contents and that "start" button at the bottom of your screen--Windows' graphical "shell") part of Windows?

At one point Apple said Hypercard was "systems software." Perhaps iTunes is "part of" OS X?

this is an old joke! (0)

Anonymous Coward | more than 11 years ago | (#5102961)


vi is an editor looking for an operating system

emacs is an operating system looking for a good editor!! ... very old joke.

interesting (0)

tps12 (105590) | more than 11 years ago | (#5102963)

This raises lots of intriguing questions. We frequently draw lines between, e.g., CLI- and GUI-based OSes, and OOP vs. functional and procedural languages. When we discuss the confluence of language and system, we need to provide for the new complexity of the resulting hybrids.

It's without doubt that the Macintosh represented the first "OOP OS." Rather than "variables" and "functions," users had "objects" that they sent "messages," like the "Trash." NeXT, and later Windows and BeOS, tuned this concept.

Probably the most "procedural OS" would have to be Unix/Linux. Just like in a language like Lisp, you need to do a certain number of things in a specific order to accomplish any given task. Very procedural.

As for a "functional OS," all I can say is that "it ain't Windows!" And I haven't even begun to touch on toy languages like Prolog and Python, nor real-time OSes. There's just a world of diversity out there. It'll be interesting to see what develops.

good programs act as an os (3, Troll)

MikeFM (12491) | more than 11 years ago | (#5102976)

Really good programs all act like a mini-OS unless they are very simple in nature. Everything from games to word processors only provide an engine and let the details be scripted in a higher level language. Web applications I design are designed around an OS-like framework that sets up the system, checks the security, passes off the task to the appropiate code, and then parses the output and sends it to the user. I've been working on a moo-style mud engine in Python and it does make heavy use of Python's security features (as well as it's own) to allow users to program the system in Python without being able to compromise the security of the system. Usually when I develop a program I look at how scripting will work even before I look at how the user interface will work.

etlinux: Linux + TCL (1)

studboy (64792) | more than 11 years ago | (#5102993)

Etlinux [etlinux.org] takes a tiny kernel, then adds radically stripped-down versions of the standard demons, rewritten in TCL!

This might in fact be your daddy's Linux: 2.0 kernel, and the TCL is a very-stripped-down one. Why? Reduced resource requirements: it'll run on a 386sx with 2M ram and 2M disk/flash!

More features:
- embedded cgi-capable WEB server
- a telnet server
- an email server, with the ability to execute commands sent by email from a remote site
- CORBA support
- easy-to-use remote file management
- a flexible package selection scheme, allowing an easy customization of the system
- source code available for every component

Black and white thinking (1)

God! Awful 2 (631283) | more than 11 years ago | (#5102994)

Saying that OSes and PLs are the same thing is a silly semantic argument, and it strikes me as an example of black and white thinking. The fact is, there is some overlap between what OSes and PLs typically do, so sometimes there is a bit of a grey area where a PL is doing an OS-like thing or vice-versa. But to say that "I cannot draw a hard and fast line between the definition of a PL and the definition of an OS therefore they are the same thing" would be wrong. OSes and PLs are different abstractions that serve different purposes, and it seems likely that there will continue to be a conceptual distinction between the two.

-a

He with the most distinctions.... (1)

pied (582557) | more than 11 years ago | (#5102995)

He with the most distinctions at their death WINS!

So now I'm suppose to erase favored distinctions rehashing it all.. again.. and again.. and again... BULOCKS! Its C/C++ and no more updates...

His languages influence his perception (1)

snStarter (212765) | more than 11 years ago | (#5103016)

I note that the languages he mentions as the ones in which me most often works are substantially scripting languages and so their deep roots into the OS are to be expected.

This is not what I thought I would find before I read the article. I thought I would be reading about a Smalltalk environment which really IS an OS abstracted on top of an OS. Or a Java IDE perhaps

I would say that old languages like FORTRAN, PL/1, C are all quite separate from the OS that supports them. Indeed C was abstracted by design with its run-time libraries holding the only knowledge about the environment in which they work.

More modern languages are seeming to migrate closer to the OS that holds them. But I would argue this is not a Good Thing because it binds a language too close to a given OS designer's viewpoint of what is important and how to look at the mechanisms under which data are displayed.

For the continued health of human-interface design, and of operating system design, I would hope that languages continue to hold the environment at bay and deal with abstractions, letting interface libraries or processes take care of display and human interaction.

Needs to be taken seriously - and generalized (1)

kovas (639677) | more than 11 years ago | (#5103018)

The way people use computers is determined by the whole of the environment they are confronted with... and generally no matter what kinds of interfaces people are presented with they will start gluing them together to get various tasks done. This is a pretty universal thing, but unfortunately the history of computing has ended up producing a rigid user/programmer distinction (although the *nix community has been doing a lot to blur the line)

No matter if you are using a GUI or a traditional programming language, the end result is that you are instructing the computer to do something. The thing is tho is that "programming" is so time consuming and difficult (compared to the GUI) that generally people only switch into that mode when they want to do something over and over again. Yet looking at the way people use GUI's, they do the same actions over and over again. Why? Because its impossible to script most GUI's in anything like an quick-and-easy fashion, or to combine elements of different programs into "meta" applications.

People have been talking about more holistic environments for years, but inevitably these projects fail. IMO its because people keep trying to use languages that are too low level and are too unstructured - causing enormous efforts to be expended on simply converting data formats or wrapping APIs and such, or chasing down buffer overflows, and not enough time developing programming environments that can program and extend themselves.

Currently I'm working on such a project based on the mathematica programming language.. stay tuned...

good idea (0)

Anonymous Coward | more than 11 years ago | (#5103022)

Quick, somebody! Come up with an OS/language environment that actually is useful!


I'm still waiting...

Soylient Green is people!!! (1, Funny)

ravic (265862) | more than 11 years ago | (#5103030)

Must be a slow news day. If this news story can make it, why not try these posts?
  1. Programming and C are the same thing
  2. North Dakota and South Dakota are the same thing.
  3. Sneakers and tennis shoes are the same thing
  4. Pop and soda are the same thing
  5. Fat and big boned are the same thing

In the Old Days (0)

Anonymous Coward | more than 11 years ago | (#5103034)

Once I worked for ICL, a British computer company.

One of the operating systems we had, VME/B, had strong support for several programming languages, including what today the nuxi world would term its shell language.

These languages all used the same architectural calling conventions, so one could call shell language as a function from S3 (the main implementation language for the system, based on Algol 68)

And call Fortran from shell.

There was no concept as limited as "main". A program was just a library, once loaded any of its functions could be called.

As a former colleague said in the early 80s, "the best that can be said about unix is that it only put operating system development back by 20 years".

In other news (2, Funny)

interstellar_donkey (200782) | more than 11 years ago | (#5103039)

Steering wheels and tires are the same thing.

Both are required for the succesful opperation of a car. Each require steel in their construction for structural reinforcement. In a pinch, and with a little engineering, theoretically one could be used to replace the other.

But most striking in their simularities: Both are round.

Ad Campaign? (1)

silvakow (91320) | more than 11 years ago | (#5103047)

"The network is the computer" -- Sun Microsystems
"The programming language is the computer" -- Matthew Flat

Am I the only one who thinks this is funny?

Programming Language == OS? (0)

Anonymous Coward | more than 11 years ago | (#5103051)

Only on Slashdot.

And still they wonder why Linux isn't a desktop platform...

Bad Titles..! (2, Interesting)

Steveftoth (78419) | more than 11 years ago | (#5103052)

Argh, this paper starts with an interesting idea, that PLs are more like OSes then we realize it, provides some genesis for the idea, but FAILS to back it up..

All of his examples, the bulk of the paper, are examples of how the RUNTIME system restricts the PL. He talks about the runtime system security model and somehow this is supposed to extend to the definition of the programming language? No, this is not how it works. The runtime system, the sandbox or whatever you call it, is a restriction defined seperatly from the language itself. The JVM is defined seperatly from the Java language. That's why products like JET exist that can compile Java code to something other then bytecode. Because the runtime enviroment is not defined in the language. You don't have to have a security manager, like in perl, you don't have to support a trusted mode in your perl runtime. It's a feature of the runtime, not the language.

The runtime, by definition is like a mini-OS. Usually, a vm runtime (for perl, java, python, etc...) takes non-native instructions, parses them and translates them into some sort of binary instruction. Since there is no processor that can execute perl natively, this is how it works.

Neat idea, bad paper.

Confusion (4, Interesting)

The Bungi (221687) | more than 11 years ago | (#5103060)

The author of the article is confused. He almos defined the term architecture but he missed it by a hair.

Systems architecture (and to a certain extent application architecture) revolves around creating "environments" where other applications operate, (note emphasis). Architectures provide services to these applications, which in turn may provide different services to yet more applications (components, web-based solutions, etc.). Thus you can argue that by sitting down and designing and implementing a specific or generic purpose architecture, you're creating a "mini-OS". That much is true. But the OS is simply a lower-level architecture than, say, Java or COM or .NET. It's a more complicated and extensive one, but one nonetheless. The stuff you do with a programming language (or as they like to be called these days - platforms) is essentially a higher-level abstraction than the real OS happens to be.

So we can argue then that we're moving towards the platform concept where things are interconnected via well-defined interfaces and entry points (that's your APIs) where the OS itself is just another component.

Load More Comments
Slashdot Account

Need an Account?

Forgot your password?

Don't worry, we never post anything without your permission.

Submission Text Formatting Tips

We support a small subset of HTML, namely these tags:

  • b
  • i
  • p
  • br
  • a
  • ol
  • ul
  • li
  • dl
  • dt
  • dd
  • em
  • strong
  • tt
  • blockquote
  • div
  • quote
  • ecode

"ecode" can be used for code snippets, for example:

<ecode>    while(1) { do_something(); } </ecode>
Sign up for Slashdot Newsletters
Create a Slashdot Account

Loading...