Slashdot Mirror

Java and .NET virtual machines are stack based, a side-effect of being designed by language programmers as opposed to chip designers. Translating from a stack based language to a register-based assembly language is a "heavyweight" operation. This means Java's and .NET's compilers and virtual machines have to be many times larger and slower than a register based virtual machine. Anyone who blames the slow down on something else has no clue (i.e. the toolkit). In contrast, Inferno's virtual machine (dis) - being designed by chip designers - was inspired to use a register based system that more closely matched the internal workings of real-world processors. They found, as RISC designers would have expected, that without a load-store design it was difficult to improve the instruction pipeline and thereby operate at higher speeds. They felt that all future processors would thus move to a load-store design, and built Inferno to reflect this.

Java and .NET virtual machines are stack based, a side-effect of being designed by language programmers as opposed to chip designers. Translating from a stack based language to a register-based assembly language is a "heavyweight" operation. This means Java's and .NET's compilers and virtual machines have to be many times larger and slower than a register based virtual machine. Anyone who blames the slow down on something else has no clue (i.e. the toolkit). In contrast, Inferno's virtual machine (dis) - being designed by chip designers - was inspired to use a register based system that more closely matched the internal workings of real-world processors. They found, as RISC designers would have expected, that without a load-store design it was difficult to improve the instruction pipeline and thereby operate at higher speeds. They felt that all future processors would thus move to a load-store design, and built Inferno to reflect this.

Just another one: c2l - C to Limbo. The only two languages Dennis M. Ritchie has documented on.

Just another one: c2l - C to Limbo. The only two languages Dennis M. Ritchie has documented on.

It's kind of unrealistic to expect software to be free from corporate interests. Even FOSS utilites that aren't directly tied to a corporation are still tied to the interests of corporate linux distributors.

That being said, I'd also like to point out that there is a completely FOSS-licensed cross-platform development environment available.

The PostgreSQL extended query protocol doesn't require escaping of any value because it won't parsed as part of an sql statement, making injection a non issue. The only sql that is parsed is supplied by the source code.

People often only get as far as writing the simple query part of the protocol which takes a stream of potentially multiple commands mixed in with data supplied by potentially hostile third parties.

I've witnessed it these past two weeks while sniffing postgresql clients while writing my own as an exercise in Limbo

Postgresql also allows the use of named queries, who stay prepared for as long as the connection is open (unless deleted deliberately).

I don't know how long the parse & prepare phase takes but I know it is not zero so there could be some speed improvement too.

I'm not convinced libpq uses it to full advantage but I didn't do in depth research, just a nod to say that if you do serious postgresql programming you could well do with looking at writing your own protcol client.

The port to Inferno is offical. This is just making Inferno into a standalone package.

Thats the great part of acme. Its also a fileserver. Actually thats the great part of Plan 9 and Inferno operating systems.

We are solving this problem at the army with inferno. Hope it can help solve your problems.

That's a similar but not same compiler suite from Inferno
http://www.vitanuova.com/inferno/

The Fourth Edition is available as Free Software under a mixture of Free Software licences (GPL, LGPL, Lucent Public or MIT-template, depending on the component).

Not plan9.

I guess they would be usable. I don't follow OpenBSD discussions but I wonder why they are no longer considered suitable for OpenBSD.

Limbo is an example of a CSP programming language. One definitely worth having a look at.

I read Slashdot every now and then. I see a lot of Java articles are made with quiet a bit of criticism. I very rarely notice that Inferno and Limbo being mentioned. With so many Linux fans it is quiet interesting seeing that it is not mentioned. Well believe it or not, Inferno and Limbo, were both researched and developed by the same people who made UNIX.

So all you Java criticizers, I am sure you will love Limbo as it seems to be exactly what you want, if you give it a chance.

I became a user of those technologies and would never look back to Java or Python. Both are true open source technologies, patent-free, portable, dynamic procceses, transparent networking, and saner garbage collection compared to Java and .Net.

Maybe we could get a review of both of these technologies on Slashdot?

I read Slashdot every now and then. I see a lot of Java articles are made with quiet a bit of criticism. I very rarely notice that Inferno and Limbo being mentioned. With so many Linux fans it is quiet interesting seeing that it is not mentioned. Well believe it or not, Inferno and Limbo, were both researched and developed by the same people who made UNIX.

So all you Java criticizers, I am sure you will love Limbo as it seems to be exactly what you want, if you give it a chance.

I became a user of those technologies and would never look back to Java or Python. Both are true open source technologies, patent-free, portable, dynamic procceses, transparent networking, and saner garbage collection compared to Java and .Net.

Maybe we could get a review of both of these technologies on Slashdot?

Limbo, its language, is c-derived, but safe. The network model makes sense. And it's mature as an embedded platform.

nope

$0 is nice but I bought my first copy of Slackware long before I could download it, I even had to copy it to (I think 22) floppies from cdrom so I could install it.

And even after I have downloaded them, I've paid for FreeBSD, plan9 and Inferno.

Free as in Freedom is more important than you give it credit for.

Just one business case is that one can mitigate risk by having multiple OS vendors to choose from. I know that if my chosen OS goes kaput or gets litigated out of existence then I won't go with it. And it doesn't cost me a fortune to try out the alternatives.

The "D" name is misleading: it has absolutely nothing to do with the creators of B or C at Bell Labs. The successor of C was Alef(the first latter of a different alphabet) which was used for the original edition of Plan 9[1], and a later descendant by the same team was Limbo(Introduction paper by no other than Dennis M. Ritchie) for the Inferno.

Both Alef and Limbo are much more interesting languages than "D", they keep the clarity and simplicity of C while providing a high level framework for concurrent systems. The only other language with a good concurrency model I know of is Erlang which is quite different but also very interesting and sadly rather under valuated.

uriel

[1] To avoid having to maintain Alef compilers for many architectures Plan 9 is ported to, it was replaced with a C library, libthread, that provides the same concurrency model, for high level programming Limbo replaced it. Libthread, despite it's name is completely different from other threading models and uses CSP to handle concurrency while avoiding locks and many other problems with traditional "threading" systems. Libthread is part of Plan 9 from User Space so you can use it in "legacy" Unix/Linux/BSD systems too(of course Inferno runs on all those systems too...)

The "D" name is misleading: it has absolutely nothing to do with the creators of B or C at Bell Labs. The successor of C was Alef(the first latter of a different alphabet) which was used for the original edition of Plan 9[1], and a later descendant by the same team was Limbo(Introduction paper by no other than Dennis M. Ritchie) for the Inferno.

Both Alef and Limbo are much more interesting languages than "D", they keep the clarity and simplicity of C while providing a high level framework for concurrent systems. The only other language with a good concurrency model I know of is Erlang which is quite different but also very interesting and sadly rather under valuated.

uriel

[1] To avoid having to maintain Alef compilers for many architectures Plan 9 is ported to, it was replaced with a C library, libthread, that provides the same concurrency model, for high level programming Limbo replaced it. Libthread, despite it's name is completely different from other threading models and uses CSP to handle concurrency while avoiding locks and many other problems with traditional "threading" systems. Libthread is part of Plan 9 from User Space so you can use it in "legacy" Unix/Linux/BSD systems too(of course Inferno runs on all those systems too...)

Who cares about Java?

We already have something far better, Limbo, it was design at Bell Labs by, Dennis Ritchie (the inventer of the C language and Co-inventer of Unix), Sean Dorward, Phil Winterbottom and Rob Pike (a lot of the Plan 9 design is thanks to him).

It is in a more free than Java (no crazy policies on what can be called Limbo), and has a more free licence than GPL2.

Unlike Java is has sane garbage collection that works, ONE sane fast toolkit module, advanced concurrency and has a C-like synax. You can read more about them in the docs.

A few more related links:
http://www.vitanuova.com/inferno/design.html
http://en.wikipedia.org/wiki/Inferno_(operating_sy stem)
http://en.wikipedia.org/wiki/Limbo_programming_lan guage
http://www.cs.bell-labs.com/sys/doc/

Who cares about Java?

We already have something far better, Limbo, it was design at Bell Labs by, Dennis Ritchie (the inventer of the C language and Co-inventer of Unix), Sean Dorward, Phil Winterbottom and Rob Pike (a lot of the Plan 9 design is thanks to him).

It is in a more free than Java (no crazy policies on what can be called Limbo), and has a more free licence than GPL2.

Unlike Java is has sane garbage collection that works, ONE sane fast toolkit module, advanced concurrency and has a C-like synax. You can read more about them in the docs.

A few more related links:
http://www.vitanuova.com/inferno/design.html
http://en.wikipedia.org/wiki/Inferno_(operating_sy stem)
http://en.wikipedia.org/wiki/Limbo_programming_lan guage
http://www.cs.bell-labs.com/sys/doc/

Who cares about Java?

We already have something far better, Limbo, it was design at Bell Labs by, Dennis Ritchie (the inventer of the C language and Co-inventer of Unix), Sean Dorward, Phil Winterbottom and Rob Pike (a lot of the Plan 9 design is thanks to him).

It is in a more free than Java (no crazy policies on what can be called Limbo), and has a more free licence than GPL2.

Unlike Java is has sane garbage collection that works, ONE sane fast toolkit module, advanced concurrency and has a C-like synax. You can read more about them in the docs.

A few more related links:
http://www.vitanuova.com/inferno/design.html
http://en.wikipedia.org/wiki/Inferno_(operating_sy stem)
http://en.wikipedia.org/wiki/Limbo_programming_lan guage
http://www.cs.bell-labs.com/sys/doc/

You might be interested in Inferno: http://www.vitanuova.com/inferno/

Anyway, in my arguments to encourage research into trying new ways of doing things, I always used Bell Labs as my favorite example/reason why we should.

That's okay, you just need to change what Bell Labs is an example of. I mean really, what has Bell Labs produced recently? Some very impressive stuff if you actually look at some of what has managed to trickle it's way out. Things like Plan9 and Inferno are actually very impressive indeed in terms of the core ideas (that is, the part the research division is responsible for). Had a little more money been thrown into really building something out of those they could have been huge. So really Bell Labs is an example of what happens when management stops paying attention to, and having faith in, their research department.

Want another example. How about Microsoft research? They have some very good people there, Tony Hoare and Leslie Lamport to name just two off the top of my head. If you dig around through some of the stuff they are working on there's some amazing ideas there. How much of that is actually seeing the light of day and making it into product? Very very little.

The reason Google seems so good is not because they have more good people doing research - in practice they probably don't. It's because management spends more time listening to and working with the research teams to see that those ideas actually get used.

The death of Bell Labs is just another example of what happens when the research department gets ignored. And yes, I am a bit bitter, having worked in a research department that regularly got ignored.

Jedidiah.

• Why Plan 9 is not dead yet And What we can learn from it by Ron Minnich from the Advanced Computing Lab, Los Alamos National Lab.
  
• The Ubiquitous File Server in Plan 9 by Dr. C. H. Forsyth of Vitanuova
  

• Why Plan 9 is not dead yet And What we can learn from it by Ron Minnich from the Advanced Computing Lab, Los Alamos National Lab.
  
• The Ubiquitous File Server in Plan 9 by Dr. C. H. Forsyth of Vitanuova
  

You mean like CSP that has been around for 20 years?

Both Inferno and Plan 9 allow CSP-style concurrent programming, and it's pure joy.

uriel

And beyond Inferno, lots of people have long wanted the plan9 C compiler to be MIT licensed so that a solid alternative to gcc could be developed. Theo de Raadt especially has talked about how much he'd love to swap gcc for the p9cc in OpenBSD.

So although not every ounce of plan9 would necessarily be wanted by someone, there are parts that people would love to have, if only for the license preventing it.

We're pretty badly off-topic here, but what the hey...

C was first designed and implemented in the time period from 1969-1973. It is hardly a critique of its original designers and implementors that we have learned a lot about programming language design and implementation in the succeeding 30+ years, and that many of the constraints of the computing environment have been weakened or removed during that time. Indeed, some of the original designers of C and UNIX spent a lot of time 10+ years ago developing an alternative language and runtime for writing operating system and application code that fixes the problems with C that I described.

"In fact, when you are coding things like process and memory mangement routines and libraries, it is very handy to be able to do arithmetic with and compare to variables that are not "exactly" the same type, if the comparison or operation otherwise makes sense. Hence, things like the boolean FALSE and integer 0 being equal (which Java will complain about) are handy."

If by "handy", parent meant "tempting" but "error-prone" and "potentially insecure", I think there's about 30 years' experience to back up this claim. Things as fundamental or important as my operating system's process or memory management routines are occasionally broken in particularly dangerous ways because their programmer did something that seemed to "make sense" at the time, even though a "safe" programming language wouldn't allow it. Go look at the changelogs of a recent UNIX kernel for plenty of examples.

"The lack of dynamic type checking, operand checking and bounds checking allows the programmer to write low level or system code that gets out of the way of higher level code." I'm sorry, but I don't know what this means.

"Imagine the performance degradation at the kernel if every comparison was dynamically checked for type, operand and bounds." One would prefer that operations be checked statically whenever possible. This is not so much for performance as because failed runtime checks in low-level code are difficult to handle gracefully. That said, as I mentioned in my previous post on this topic, we have known for a long time how to build programming languages so that a combination of static and runtime type and operand checking will provide some correctness guarantees without signficantly impacting execution performance. IMHO, it's way past time to start using that knowledge.

And what non-linux, non-BSD OSes are around now?

There's Plan 9 and Inferno. I haven't had much opportunity to experiment with either one, but they both look really interesting. There's also Hurd, but as far as I can tell (which admittedly isn't very far) it's currently about where it was in the nineties in terms of actually working.

Well, even though it's obvious you don't know what the hell you're talking about, since you think J2EE == applets, go ahead and check this out.

Brain required, just FYI.

From a conversation with a friend earlier today:

"OpenBSD was my first *NIX, and I thank God for initiating me to Unix with the only barely sane *NIX at the time."

Of course this days I know of better things.

This seems quite similar to the concept of Inferno (http://www.vitanuova.com/ from Vita Nuova Limited, except Inferno runs hosted on the operating system (it can run natively). Similar concept, different implementation. I'll stick with Plan 9, though :)

This is what it means for me: http://www.cs.bell-labs.com/who/rsc/thread/

Also see Brian W. Kernighan's "A Descent into Limbo" and Dennis M. Ritchie's "The Limbo Programming Language".

And of course Hoare's classic: Communicating Sequential Processes.

Now you can enjoy the power and beauty of the CSP model in Linux and other Unixes thanks to plan9port including libthread and Inferno; yes, it's all Open Source.

This is what it means for me: http://www.cs.bell-labs.com/who/rsc/thread/

Also see Brian W. Kernighan's "A Descent into Limbo" and Dennis M. Ritchie's "The Limbo Programming Language".

And of course Hoare's classic: Communicating Sequential Processes.

Now you can enjoy the power and beauty of the CSP model in Linux and other Unixes thanks to plan9port including libthread and Inferno; yes, it's all Open Source.

This is what it means for me: http://www.cs.bell-labs.com/who/rsc/thread/

Also see Brian W. Kernighan's "A Descent into Limbo" and Dennis M. Ritchie's "The Limbo Programming Language".

And of course Hoare's classic: Communicating Sequential Processes.

Now you can enjoy the power and beauty of the CSP model in Linux and other Unixes thanks to plan9port including libthread and Inferno; yes, it's all Open Source.

If you want examples of operating systems that help with gridding, check out Plan 9 from Bell Labs and it's sister project Inferno. Nice thing about Inferno is that it runs on Linux, Windows, Mac OS X, Plan 9, and on native hardware.

the most "interesting" operating system i know of, Inferno, doesn't make use of a MMU. it's designed to be able to run on very minimal or embedded-style hardware (or as an application on top of another OS). it's got some really fascinating characteristics, and its handling of networking in particular is still way ahead of anything else out there, even eight years after its initial beta release. your comments about performance are still entirely appropriate, but there's plenty of very interesting - and even general purpose - things to be done with this.

It seems some people are desperate to do anything to avoid actual implementation (work?)

People are avoiding not just work but also the effort of learning anything substantial (and therefore difficult). It is easy to learn this sort of fluff; it is not quite so easy to learn some interesting languages designed to solve real problems.

• Plan 9
• Inferno
• EROS

unlike French, which has an official language institute, an arbitrary organization's style guide does not dictate "correct" English in either of its major variants (although such things are useful reference points in both). try google searches for things like "BT are" site:co.uk or "GNER are" site:co.uk for a rather lengthy list of examples from British speakers, including folks like the Manchester council leader. i can point you to a substantial collection of press releases by British companies if you like, too. this is also certainly common practice in speech in England (or at least in London, where i lived for a good while). even a search in one of your own publications for, say, "BT are" site:guardian.co.uk yields a number of relevant hits (although to your publication's credit, most - but not all - i found before i stopped skimming google's second page are quotes from other people).

i will certainly concede that this practice is not universal in British English - Vita Nuova has recently changed their web site to treat the name a singular, for example - but then, such was never my claim. i claimed that British folks speak this way. perhaps i should have explicitly included the "tend to".

• Plan 9
• Inferno
• EROS

plan 9 is nice, and to give you an idea of the power and extensibility of it, go play with Inferno.

while programming in a multithreaded/multiprocessor environment takes a bit more thought than programming otherwise, it's not nearly as hard as it used to be - or rather, it needn't be so. many modern languages (like my favorite, Limbo) can give you multithreading support (with or without multiprocessors) effectively for free. as long as that goes with light-weight threads (like Inferno and Plan 9 give, or with the stupid "special light-weight process" junk present in many unixes), you've got most of the battle won (there's still some design questions to answer, but all your crap work goes away). even the older languages have a plethora of thread models that work (some better than others), at least enough to make it so that you don't have to think about threading more than the problem you're actually trying to solve. in these languages it's certainly not "free", but it makes the cost/benefit tradeoff much more reasonable than it used to be.

while programming in a multithreaded/multiprocessor environment takes a bit more thought than programming otherwise, it's not nearly as hard as it used to be - or rather, it needn't be so. many modern languages (like my favorite, Limbo) can give you multithreading support (with or without multiprocessors) effectively for free. as long as that goes with light-weight threads (like Inferno and Plan 9 give, or with the stupid "special light-weight process" junk present in many unixes), you've got most of the battle won (there's still some design questions to answer, but all your crap work goes away). even the older languages have a plethora of thread models that work (some better than others), at least enough to make it so that you don't have to think about threading more than the problem you're actually trying to solve. in these languages it's certainly not "free", but it makes the cost/benefit tradeoff much more reasonable than it used to be.

...and devices are too tightly tied to a specific kernel.

...and devices are too tightly tied to a specific kernel.

There's also Inferno, a spin-off of Plan 9 that runs in a virtual machine on top of Linux, BSD, Mac OS X, Windows, and Plan 9 (and others). Acme is included and you get the basic feel of Plan 9. Worth a look.

If you want to give Acme a try (I love it), you can do one of two things:

A: Download Inferno. It's a Virtual Machine-based operating system that runs on top of Linux, Mac OS X, Windows, and Plan 9 (to name a few). Acme is included. Free to download.

Or B: plan9port. It's a port of the Plan 9 libraries to UNIX, including Linux and BSD. Acme is included (screen shot under KDE). Again, free to download.

You should read the Plan 9 wiki entry on acme before trying to use it.

Enjoy!

Rob's opinion of OO is well known; one of my favorite quotes by him is: "object-oriented design is the roman numerals of computing."

As for building on Unix and C, his(and Bell Labs') answers are well known:

- Plan 9
- Limbo
- Inferno
- [New]Squeak

Rob's opinion of OO is well known; one of my favorite quotes by him is: "object-oriented design is the roman numerals of computing."

As for building on Unix and C, his(and Bell Labs') answers are well known:

- Plan 9
- Limbo
- Inferno
- [New]Squeak

> > Lets have the BEST of everything in one core repository.

> like This[www.freebsd.org] one?

Sorry, I'm sure you made a small mistake...

The one you were thinking of is This one.

Or maybe This one.