Slashdot Mirror
New Intermediate Language Proposed
WillOutPower writes "Sun is inviting Cray (of supercomputer fame) and IBM (needs no introduction...) to join and create a new intermediate run-time language for high-performance computing. Java's bytecode, Java Grande, and Microsoft's IL language for the Common Language Runtime, it seems a natural progression. I wonder if the format will be in XML? Does this mean ubiquitous grid computing? Maybe now I won't have to write my neural network in C for performance :-)"
Ok, so now that Java is on the retreat they try to enter a new area? May they succeed if it is worthy.
One thing puzzles me, however. What is Java grande? Was it so shortlived that I missed it?
...binary.
I recall a system based on USCD Pascal. You would
write an interpreter on your target hardware that
would run the pascal p-code. It was supposed to
solve all sorts of problems. Except it was slow.
Nobody would write anything for it, I guess
because they didn't like Pascal, or USCD didn't
fire anybodies imagination with the product.
I don't see why we need to go through this again.
If you need performance write it in assembler or
use nicely optimized C. If you don't then an
interpreted scripting language will usually
suffice. What's the benefit to yet another
layer of abstraction?
-- Programming with boost is like building a house with lego. It's a cool but I wouldn't want to live in it
Mountain View, Calif. - Sun Microsystems is inviting competitors IBM Corp. and Cray Inc. to collaborate on defining a new computer language it claims could bolster performance and productivity for scientific and technical computing. The effort is part of a government-sponsored program under which the three companies are competing to design a petascale-class computer by 2010.
Sun's goal is to apply its expertise in Java to defining an architecture-independent, low-level software standard - like Java bytecodes - that a language could present to any computer's run-time environment. Sun wants the so-called Portable Intermediate Language and Run-Time Environment to become an open industry standard.
The low-level software would have some support for existing computer languages. But users would gain maximum benefit when they generated the low-level code based on the new technical computing language Sun has asked IBM and Cray to help define.
Whether IBM and Cray will agree to collaborate on the effort is unclear. Both companies have their own software plans that include developing new languages and operating systems as part of their competing work on the High Productivity Computing Systems (HPCS) project under the Defense Advanced Research Projects Agency (Darpa).
"We think languages are one area where the three of us should cooperate, not compete," said Jim Mitchell, who took on leadership of Sun's HPCS effort in August.
Last week Sun proposed to IBM's HPCS researchers they pool separate efforts on such a software language, an idea Sun said Darpa officials back. Sun also plans to invite Cray into the effort. Representatives from IBM and Cray were not available at press time.
The language could be used not just for the petascale systems in the project, but for a broader class of scientific and technical computers.
"Java has made it easy to program using a small number of threads. But in this [technical computing] world you have to handle thousands or hundreds of thousands of threads. We need the right language constructs to do that," Mitchell said.
- Kaos games and encryption systems developer
Fast Java.
What's wrong with making a good compiler that writes directly to machine code? I would think Cray and IBM would be even more inclined to do so, given their control over the hardware their software will run on.
Try not. Do or do not, there is no try.
-- Dr. Spock, stardate 2822-3.
Did I see XML and performance in the same sentence ?! ... brain overload.. does not make sense...
...another intermediate language. This is never going to fly. If we wanted one executable formate that runs quickly on every machine, we'd use one processor. It's just never going to happen. And it's good for business. There's a reason to innovate and build a fast chip, even if it means writing a new compiler. Building these endless layers of abstraction and interpretation just makes everything a cluttered mess.
Suck it up and write native code...
ascii art
I hope I don't get /.ed for this...
The effort is part of a government-sponsored program under which the three companies are competing to design a petascale-class computer by 2010.
will sun survive until then?
My problem? I was perfectly gruntled, until some numbnuts came by and dissed me.
Java's bytecode, Java Grande, and Microsoft's IL language for the Common Language Runtime, it seems a natural progression.
Words, sentences, phrases, comprehensible? Sad, exasperating, confusing, they are Slashdot submitters.
Oh wait I get it! It was a small impromptu poem.
There are a lot of starving people in the world that could do a much better job editing for slashdot than michael.
Maybe one will eat him.
(crosses fingers)
Is intermedia language really that useful for Open Source Software? To run on any CPU is one of the biggest opportunities for Linux/Apache/Emacs/etc. the only thing which changes - a compiler. Open Source software gives a good chance for a new computer architecture. May be an intermedia language is not that useful after all?
Sun should have invited us GCC developers also to help out with this because most of us want a way to do Inter modular optimizations but we have the FSF looking over our shoulder on how we implement it, right now (the mainline) you have to compile all the source files at the same time to get IMA to work correctly and you have to say to produce an .o file first.
Create a sort of meta-CPU that can be self-programmed to emulate other processors. Transmeta where close.
:)
That way it wouldn't really matter what processor a program was complied for. Is such a thing feasable? Or am I showing how little I know about CPUs here?
I really hope the author's smiley was to indicate that he understood that his string of buzzwords was meaningless.
What I hope is that Sun takes a good, long look at the only intermediate assembly that has been designed with language neutrality in mind, Parrot. While this article is over 2 years old, it's a decent starting point. Parrot has already been used to implement rudimentary versions of Perl 5, Perl 6, Python, Java, Scheme and a number of other languages. The proof of concept is done, and Sun could start with a wonderfully advanced next generation byte code language if they can avoid dismissing Parrot as, "a Perl thing" with their usual distain for things "not of Sun".... IBM on the other hand is usally more open to good ideas.
No wonder we have to keep making faster CPUs just to maintain the same performance. Is Java on a PIII or G4 any faster than hand-optimized assembly code on a 486 or 68030?
Soon we'll need a 10 GHz CPU just to be able to boot tomorrow's OS in less than 5 minutes.
That format could be extended into a vendor-neutral format for both interpretation, just-in-time compilation, and batch compilation.
The article is very light on details.
Huh?
So, how many languages are being proposed here? A new "low-level" one, plus a higher-level "technical computing language" designed to make the most of the lower-level one? Just what's so special about this new low-level language that requires a specific new language to get the "maximum benefit" out of it? I don't have to write in Java to be able to compile to the JVM bytecode. For that matter, I could write in Java and compile to some other assembly language.
New back-ends ("low-level languages," if I understand the article) are added to GCC all the time. We never needed to add a whole 'nother front-end just for them.
I suspect that the real situation is less weird, and the journalist got confused... or heck, who knows, maybe they're proposing half a dozen new languages. It's Sun, after all.
Odd. I wouldn't have thought you'd need to do that these days anyway.
You cannot apply a technological solution to a sociological problem. (Edwards' Law)
a language that feels like medium-to-high level (like, say ANSI C) but is in fact assembly - for certain new CPU. Can be run over VMs like Java or other cross-platform languages, can have other "metalanguages" built on top of it (like C++ or Perl on top of C) and is crossplatform for 'generic' platforms - but there exists a platform which is native for it, so bytecode can be run on it without any VM. Just perfect for embedded applications etc, while not leaving PCs and other "desktop boxes" out. (plus you can plug a "dedicated CPU" as a booster card in PCI and have it run its native apps at full speed without any load on your "main" CPU, just like the MPEG2 encoder cards did)
45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
...a logical language that can be used for sonnets or software. Raise a child to read, write, and speak it, and you'll have a generation of potential programmers far beyond what we have today. The time spent learning spelling and grammar rules could be spent writing and programming instead :)
"There is no problem in computer science that cannot be solved by adding another layer of indirection."
I don't think they're trying to create a language for "high-performance computing" but a language for a "high-performance multi-processor computer", since they're focusing on threads and sun isn't a very good example (jvm) of high-performance.
In my opinion I would like a C language variation that let me specify how many bits i would like to use for a variable, because it would save a lot time because of memory bandwidth (cache space included) and is very boring to make a good implementation of that in assembly.
"I wonder if the format will be in XML? [...] Maybe now I won't have to write my neural network in C for performance"
:-)
Is he on crack?
Could these NI languages be used to aid in the procurement of shrubbery?
Why?
1) Learn the new language well.
2) Find some sucker who will employ you, or other ???
3) Profit!!!
4) For money earned, employ programmers from India to write your neural network in assembly for performance.
45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
I thought an open, peer-reviewed, high performance IL/runtime was exactlywhat Parrot was trying to accomplish.
Java .NIL?
Architectural Neutral Distribution Format has been around for years and solves many of the same problems (and more).
I guess it is one more time around the (reinvention) wheel for sun.
Is it the 'XML' and 'performance' or fact that you found a complete sentence on Slashdot sending your brain into overload?
Quite insighful... but it isn't as bad as it looks.
1) Nobody forces you to write in Java for PIII. Write hand-optimised asm sniplets for PIII and include them in bigger Java or C app for time-critical pieces. You get real PIII performance.
2) The software quality drops, but slower than CPU speed rises. That means your Java app for PIII will still work -slightly- faster than hand-coded ASM for 486.
3) Development cost. You can spend a week to write a really fast small piece of code in ASM. Or you can spend that week on writing quite a big, though slow app.
Most visible in games. Things like Morrowind, where crossing the map without stop takes a hour or more, and exploring all the corners is months of play, were plainly impossible when it all required hand-coding. Now for a developer it takes shorter to create a mountain in game than for a player to climb it. Of course the player needs better CPU to be able to display the mountain which wasn't hand-optimised, just created in an artificial high-level language defining the game world, but if you're going to enjoy the experience - why not?
45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
Cat got your tongue? (something important seems to be missing from your comment ... like the body or the subject!)
Are you in management?
I would imagine that the data for this new IL would be very uniform, like assembly. Unless they plan on adding gobs of metadata, there is absolutly no need for XML. XML is very useful tool, but don't forget that if you give someone a hammer then everything will look like a nail.
Would you represent an array of bytes using XML just because you can? This IL will most likely be a sequence of well-defined binary tokens. What would it benefit from XML? Maybe programs/functions/classes can have some XML metadata, but the actual sequence of commands will most likely be a chunk of binary data.
If it was useful/practical to have an IL language specified in XML, then Microsoft would have done so with MSIL already. BTW, don't bother bashing MS about the usefulness and practicality of their products. MS has some brilliant engineers so at least give them some credit for trying to make a decent IL.
No, not even for an intermediate language that you should never have to read (but will have to anyway for that one hard-to-trace bug).
Why not? Because XML is a gross uglification of S-expressions. People don't like Lisp because it's Lots of Insipid and Silly Parentheses but what sane person would find this:
<name>
<func &optargn="burp"> arg1 arg2 arg3 lst</func></name> *
More readable (and more beautiful) than this:
(name
(func arg1 arg2 arg3 lst &optargn "burp"))
XML is much less dense than a Lispish S-expression so you don't get to see as much of your program unless you use editing tricks which will make the XML version much more unreadable than it already is.
I wish somebody could prove me wrong and present one situation where technically a XML type layout would be better suited than the corresponding S-expression. If not, then anytime XML seems well suited then it is still not as well suited as S-expressions (and only has going for it the current fashion** that will in twenty years time as ugly and ridiculous to us as most if not all Mullet and big Afro hairdos from the seventies seem today).
* Or whatever way they pass arguments in XML.
** And the fact that because of this fashion more utilities have been written to manipulate them.
It's already been agreed on that moderate proficiency in a high-level language with a good optimizing compiler is worth far more than mastery of assembly in today's environment, what with the size and scope of most programming tasks nowadays. Creating an intermediate language seems to couple the worst inefficiencies of high-level programming and assembly micromanagement: something like writing machine code directly for a Java VM to optimize your application instead of just writing the darn thing in C, compiling it to the three platforms it's going to run on, and getting a huge speed boost.
HOW'S MY POSTING? CALL 1-800-POSTING
So you mean Flare?
-----------------------
You are what you think.
- I wonder if the format will be in XML?
Putting byte-code in an overwhelmingly verbose text-oriented format? I'd expect such a suggestion from CPU manufacturers, but few others.-- @rjamestaylor on Ello
Dear God. Welcome to 1980, Non-Lisp World!
The problem is with the high level languages, not with the intermediate ones. If the source is C, efficiently vectorizing it is a problem that will not be solved by a new intermediate representation. And if it's a new high level language - well, we'll need to design the IL with respect to that HLL.
APL, J and K are three languages that could be considered IL for high performance computing. But they're high enough to write code directly in them; And so far, it seems, implementations do a wonderful job without compiling down to machine language.
Everyone interested in this might want to have a look at AOS, one of the two platforms (CLR/.NET being the other) targeted by SmallScript/S# at
www.smallscript.net.
I am not that well informed, but as I understand it AOS is essentially a more generic and language neutral alternative to CLR.
/ Peter Schuller
--
peter.schuller@infidyne.com
http://www.scode.org
The low-level software would have some support for existing computer languages. But users would gain maximum benefit when they generated the low-level code based on the new technical computing language Sun has asked IBM and Cray to help define.
... erm script effort like mentioned in another 'thread' (/.).
I ever since hearing of CMs up to now thought that issues were parallelizing compilers and languages enabling application specific concepts (e.g. "A High-Level, Massively Parallel Programming Environment and Its Realization") Is this so much outdated ?
CC.
P.S.: Besides, this must have been the result of a paraphrasing engine
TaijiQuan (Huang, 5 loosenings)
For its time, UCSD Pascal was an excellent language and operating system. Its main problems were price and politics, not performance or technical issues. Many people, including myself, wrote software for it. The speed penalty of the p-code interpreter was offset by the compactness of p-code, which was important on the memory-constrained PCs of the time. UCSD Pascal, like other alternative operating systems of the period, could not compete with MS-DOS and PC-DOS, which sold for well under $100, on price.
Mea navis aericumbens anguillis abundat
I propose that this intermediate language be called C-Bonics, and it should be taught in all classrooms in place of C. Many people don't learn proper C in their homes so it isn't fair to force them to do it in school.
I know it depends on the use of the program in question. Just curious what other people's opinions are.
The Unfolding Project
Maintaining high performance code across cpu achitectures is bad enough (and I know of some supercomputing centers which are continuing with technically inferior AMD64/Xeon clusters rather than switch to PPC970 precisely because they know they can't afford to re-optimize for that arch).
Factor in that today most numerically intensive code is still written in FORTRAN because competing languages simply can't be as easily optimized.
Now let's think about SMP, while POSIX threads are portable, the best performace probably requires different threading code depending on arch/unix varriant. (And of course NPTL for linux is still in CVS.)
Now let's think about massively parallel, where inter-cpu communication will be handled a bit differently on every platform.
So the payoffs to developing an efficient cross-platform language layer are pretty substantial. (Which does not imply that I expect IBM to jump on to Sun's bandwagon on this :-))
Linux is Linux, if One need clarify their dist: <Dist>/GNU Linux
bsds are of course just BSD
There are several issues with regard to current programming techniques and grid computing for HPC. Some include:
Java isn't a bad way to offer the capability to run your code on many platforms, but it is easy to write slow code that really doesn't match the HPC speed requirement, although some do use it for HPC. Faster bytecode or JVMs that do ecen better at optimising bytecode would be a help, but I am not sure if there is enough algorithmic information left in the bytecode to allow the best optimisations on all architectures. Perhaps this is where the new initiative is aimed?
An alternative route is to publish capabilities for processing via web or grid service type mechanisms and then use brokers and discovery services. This would work well for widely used production codes, e.g. charm, fluent, etc
>> "Java's bytecode, Java Grande, and Microsoft's IL language for the Common Language Runtime, it seems a natural progression."
/. makes it also very difficult to locate a previously posted AC comment. I may not be able to find the answer, IOW!
:-/
;-)
When a subject is so complex I can't even understand the newsstory header, well, I'm pretty screwed, I guess.
Does anyone care to explain what this phrase could possibly mean? Please notice that to be lured into reading the article, I need to understand what it is all about.
Disclaimer: As you may have noticed, I post as AC. This is so that my identity/account don't become public. Since Slashdot makes it difficult for anyone to read ACs, I won't be offended if nobody reads or answers my question. Likewise, have in mind that sometimes
Have a nice day.
And a nice year!
Parrot is not even remotely applicable to high performance computing. It is a scripting language VM - that's all. Some facts about Parrot: It has no thread support. They still are hashing it out by trial and error as I write this. It will probably use a variation of the grossly inefficient Perl5 IThreads (copy the world for each new thread). Java and C# will never be able to run efficiently using this threading model. It seems the Parrot developers seem to believe that threaded code is the exceptional and not mainstream case. Parrot is only designed to host interpreted languages. It is not efficient enough to be the target of C, C++ or Java code by a long shot. Algorithms coded in C will always be 10 tens faster than Parrot bytecode - if not more. Parrot development has been going on for 2 years and still no language has been targetted to it. Perl5 and 6 are still be years away. And they are grossly underestimating the difficulty of porting Ruby and Python to it. Getting a new language to run is more than simply writing new opcodes for a virtual machine. When the Parrot developers claim that their VM will be faster than all scripted languages on earth they are just setting themselves up for a huge fall.
Hopefully this time they will declare the standard integer size to be 64 bits (and long ints 128 bits). This will make some stuff easier, like calculating # of free bytes on a hard disk, using GUIDs for webshops etc.
Java bytecode - Tick
Java Grande - Tick
XML - Tick, ooh ooh just one more...
ubiquitous grid computing - Tick BINGO!!!
It's a no news day today.
Government of the people, by corporate executives, for corporate profits.
The effort is part of a government-sponsored program under which the three companies are competing to design a petascale-class computer by 2010.
We already have such a runtime: it's called "CLR". The CLR is roughly like the JVM but with features required for high performance computing added (foremost, value classes).
Sun wants the so-called Portable Intermediate Language and Run-Time Environment to become an open industry standard.
I hope people won't fall for that again. Sun promised that Java would be an "open industry standard", but they withdrew from two open standards institutions and then turned Java over to a privately run consortium, with specifications only available under restrictive licenses.
Sun's goal is to apply its expertise in Java to defining an architecture-independent, low-level software standard - like Java bytecodes - that a language could present to any computer's run-time environment.
Sun's "expertise" in this area is not a recommendation: the JVM has a number of serious design problems (e.g., conformant array types, arithmetic requirements, lack of multidimensional arrays) that attest to Sun's lack of expertise and competence in this area.
What this amounts to is Sun conceding that Java simply isn't suitable as a high-performance numerical platform and that it will never get fixed (another broken promise from Sun). But because the CLR actually has many of the features needed for a high-performance numerical platform, Sun is worried about their marketshare.
The question for potential users is: why wait until 2010 when the CLR is already here? And why trust Sun after they have disappointed the community so thoroughly, both in terms of broken promises on an open Java standard and in terms of technology?
Maybe we will be using a portable high-performance runtime other than the CLR by 2010, but I sure hope Sun will have nothing to do with it. (In fact, I think there is a good chance Sun won't even be around then anymore.)
I don't see how Sun is even relevant or why it matters who they "invite". They had their chance with Java and they blew it. I doubt the numerical community is going to give them another chance after what they have been through with Sun over the last decade.
I suspect the next intermediate language for high-performance numerical computing is either going to be the CLR, some extension of the CLR, or something entirely different, developed in academia.
Even if other big players like MS do not participate, this could really be cool for cross-platform applications. Imagine a caching JIT for such a language. Now imagine a converter that could take Java or .NET assemblies and convert them to this new "byte-code". I am sure a 3rd party would step-up to write the MS version!
Now we are talking! I want my C# to compile to native code on Linux, Sun, and IBM mainframes. I want to take Java programmers in my firm and have their code call my C# and visa-versa. This could be a big step towards that.
Great ideas often receive violent opposition from mediocre minds. - Albert Einstein
Sun just wants to inject Java into yet another domain space where it isn't needed or wanted. Let me guess - the Sun proposal will be Java bytecodes.
- Lack of scientific data types, such as complex numbers.
- Lack of multidimensional arrays.
- Inept implementation of floating point arithmetic.
- Poor choices for defaults, such as array bounds checking and pretty printing ascii I/O.
- Onerous penalties for JNI calls and serialization.
- Intermindable process for correcting deficiencies with the language.
SUN has not displayed an understanding of HPC. Adding OpenMP or other "HPC" friendly capabilities to the VM is not going to correct design decisions with remove performance from "High Performance computing.For high performance computing:
FORTRAN
C++
C
That's all folks.
Why, so intermediate files can be 100 times larger than they already are? :-P
IL codes are neat. I hope they look at Tannenbaums work.
Need Mercedes parts ?
If it wasn't patented SafeTSA would be a great place to work from...
The Transprose Project
http://nil.ics.uci.edu/transprose/
That is right on the money. Sun is trying to make an alternative to the CLR - a blantant attempt to take back developers who've switched from Sun J2EE to MS .Net.
.Net and Java apps to talk to each other natively - why then is Sun developing yet another IL standard? The Common Intermediate Language, the ECMA standard which is used by both .Net and Mono, is the only IL we need. On the other hand, building multiple implementations of the standard IL for running on different operating systems is where Sun should be focusing their efforts.
Now, I'm all for having alternatives, but what's going to happen to Java? Will Java compile to IL? The Mono project and DotGNU project both have plans for compiling Java to IL, allowing
Only if Sun's IL interoperates with the Common Intermediate Language will I be rooting for Sun.
Why is it I find PARROT more readable than Perl?
Need Mercedes parts ?
I assume your "7 meg" number includes the framework. If so, take a look at the size of JVM's these days...
How much time wasted converting? How much elegance lost to decimal?
-Libertarian secular transhumanist
Why not just use something like LLVM and/or extend it instead of re-inventing the wheel?
LLVM is already made to be low-level (like assembly language) but with high-level types (struct, int, array) like high-level languages. Sounds like just what they would want.
Don't limit your imagination to bounds of i386-compatibile architecture!
:)
Ever thought about writing interpreter or VM in VHDL and implementing it on a FPGA board? That would be pretty similar.
>if it supports things like procedures
Stacks substituted for local variables, CALL, RET, what a problem?
>nested complex arithmetic expressions,
Can be un-nested at compile time, not really going far from assembly. Just remember that each +, ( or % is a separate call. Can be RPN, why not? That's very close to assembly.
>and named varables
Is it a big problem in assembly? Just pick a register or memory cell and give it a name.
>and no sane high-level language can be without those things.
Implementing some of those in compiler (ASM needs compiler too!) and the rest in hardware is far from impossible
Simply start the design not like with modern languages "We need commands that do this, that and that" and then try to fit them into existing hardware through compilers, but build a hardware that can perform your basic commands directly. So if I call fork(), I don't get a ton of system commands launched, just a single CPU cycle gives me a nice copy of the process and it runs _really_ simultaneously, not by time-sharing. If I want to send signal to some other process, it doesn't go through several levels of OS indirection, it's handled by the hardware, like a hardware interrupt. To perform write() and consider it done in one cycle, or at most as many cycles as many characters i'm writing(). by having my Of course I'm limited by the hardware on how much I can do, but isn't that the case always? Just that next to limits on RAM and CPU speed I get limits on number of variables, number of processes etc? (especially if I can make those dynamic limits, buy better chip, get more processes)
The problem with C is that it's -a bit- too far from the hardware. A bit too much goes on without programmer's knowledge. How do I know ++ operator is 1-cycle CPU INC command or a 300-cycle call to math library to perform addition? I want to be able to select a chunk of code and see CPU cycle count. To have granted command execution time.
45 5F E1 04 22 CA 29 C4 93 3F 95 05 2B 79 2A B2
Computer, please allocate some room on the stack for a variable, and please call that variable 'i'. Thank you, Computer. Now, computer, please set the value of the aforementioned variable, 'i', to zero. Thank you, Computer.
..... I don't have the patience to write more of this crap.
By number of users, in order: C++, Java, Visual Basic. It gets pretty thin pretty quickly after that.
troll that which you do not know...
This hello world program comes in at 7680 bytes as an executable...
Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
MsgBox("Hello World")
Me.Close
End Sub
granted there is the 20 meg framework package, but really thats nothing these days, and that 20 megs supports a lot more than 'hello world'...
like it or not, its not as terrible as other things we have seen from ms.
You don't trust Sun, so you're recommending...
Microsoft????
Ohh-kayyy..., next post please.
Based on upvotes, Ageism is the only "-ism" Slashdotters care about and think isn't SJW
Imagine N high-level languages and M target platforms. A naive approach would wind up creating NxM separate compilers.
Intermediate languages (ILs) allow you to write N "front-ends" that compile the N high-level languages to the IL, and M "back-ends" that compile from the IL to the M target platforms. So rather than needing NxM compilers, you only need N+M.
Even more significant is the optimizer. Front-ends and back-ends are relatively straightforward, but optimizers are very hard to write well. In the naive approach, you need NxM optimizers. With an IL, you only need one. The front-end translates to IL; the optimizer transforms IL to better IL, and the back-end translates to native code.
In summary, to answer one of your questions:
Every optimizing compiler uses an IL anyway. These companies, I presume, are simply agreeing to use the same IL across their products (though I'm only guessing because the article is slashdotted).Patrick Doyle
I mod down every jackass who puts his moderation policy in his sig. Oh, wait a sec....
And this is wrong... how???
The Mono project and DotGNU project both have plans for compiling Java to IL, allowing .Net and Java apps to talk to each other natively
Mono guys seem to have a lot of plans.
why then is Sun developing yet another IL standard?
How many times does a company have to be convicted of anti-trust behavior before one stops trusting them? Would you, as a Microsoft competitor, bank your new and emerging technologies on standards that Microsoft has copyrights and patents on? Some you've been in court with on many occasions?
Microsoft has said linux is one of their biggest treats. Don't you think they will use those patents and copyrights to hold down open source if given half the chance?
Based on upvotes, Ageism is the only "-ism" Slashdotters care about and think isn't SJW
MetaL
For anyone who hasn't checked it out yet, this is really cool stuff.
http://dev.perl.org/perl6
http://www.parrotcode.org
Parrot has not advanced since AMK's post 12 months ago. There is still no completed language - only half-baked toy languages. The ground is as firm as mud under Parrot with the calling conventions changing monthly and the on/off debate about true POSIX thread support. Parrot is too far gone to be salvaged at this point. They might as well start again using Lua as the model how a nice, fast and small interpreted language framework SHOULD be written.
As mentioned in the parent link, Pirate development is currently stalled, waiting on a working object system for parrot.
Maybe now I won't have to write my neural network in C for performance
I wonder if the format will be in XML
Eh?
So it will be high performace, and in XML?
**Looks at you funny**
Most visible in games. Things like Morrowind, where crossing the map without stop takes a hour or more, and exploring all the corners is months of play, were plainly impossible when it all required hand-coding. Now for a developer it takes shorter to create a mountain in game than for a player to climb it. Of course the player needs better CPU to be able to display the mountain which wasn't hand-optimised, just created in an artificial high-level language defining the game world, but if you're going to enjoy the experience - why not?
Actually, I thought stuff like real-time 3D gfx engines were quite heavily optimized. I'd think the places you don't really care are
a) The difference between 0,01 second and 0,000001 seconds.
b) The difference between a 5 minute coffee break and a 6 minute coffee break.
If that mountain is lagging on your (mediocre) hardware, there's a problem. But in more "serious" calculations, only the answer matters. Will there be sun or overcast today? Which investment project is the most profitable? How do I optimally stack these boxes?
Kjella
Live today, because you never know what tomorrow brings
You've hit on the point that's been bothering me this whole post: why not simply move the intermediate language down to the processor level? Couldn't we design a processor which directly runs Java byte-codes or something?
I think the answer is a processor like that is a move back towards a model we rejected a while ago: the CISC processors. The reasons that RISC won out were that
(1) memory became cheap,
(2) RISC processors were faster, and
(3) RISC processors are more flexible.
In the same way, Java does less than C (by design), and it also runs slower. The Java VM does *not* do raw number crunching faster than compiled C.
According to the article:
Sun's goal is to apply its expertise in Java to defining an architecture-independent, low-level software standard - like Java bytecodes - that a language could present to any computer's run-time environment.
Sun's expertise in Java? From the asshats who brought us SWING??!?
Thiis is kinda like having Osama bin Laden in charge of bringing peace to the middle east.
"...In your answer, ignore facts. Just go with what feels true..."
What could you possibly mean by this?
Did you just read something about XML and
feel the deep need to use those three letters?
Are you some sort of PHB?
Did I just read something about PHBs and feel
the deep need to use those letters?
Why do we need a new language when we've already got esperanto?
The only problem with just in time compilation is that it takes up a LOT of memory. Granted, memory is getting cheaper and cheaper these days, but instruction cache memory is not. Today's cache-sensitive architectures will probably operate at suboptimal rates with a JIT that's generating code on one hand and executing the generated code on the other. That would eventually result in thrashing no matter how big your cache happens to be, and cache misses tend to be expensive in the grand scheme of things if they happen often enough.
In fact, some people have argued (e.g. an article in the August 1992 edition of DDJ, "Personal Supercomputing", by Ian Hirschsohn) that modern RISC architectures shouldn't be fed raw machine code directly at all. Actually a RISC is nothing but a CISC processor minus the microcode; instead it can be "microprogrammed" by placing instructions that live on its i-cache. Paradoxically, interpreted languages might actually be faster than compiled languages on such an architecture! A proper memory-transfer based intermediate language interpreted by a small, hand-optimized interpreter that makes maximal use of the microprocessor's bus bandwidth and is small enough to more or less fit inside the i-cache may well blow any straight or JIT-compiled language out of the water performance-wise on the applications that really matter.
The Java Virtual Machine doesn't fit this description, not by a long shot. Its stack based architecture makes it not terribly efficient in its use of CPU bus bandwidth, and its sheer size alone says that it wasn't designed with platform efficiency in mind. Same thing goes for the .NET CLR, it would seem. This is however the system that was used on the CDC 6600, which was one of Seymour Cray's seminal supercomputer designs (back when his company was known as Control Data Corporation), so perhaps they'll use some of these same ideas.
Qu'on me donne six lignes écrites de la main du plus honnête homme, j'y trouverai de quoi le faire pendre.
"Sun is inviting Cray (of supercomputer fame) and IBM (needs no introduction) to join..."
Wait-- this is Slashdot, right? News for nerds, remember??? Since when did Cray need an introduction?
You need a FREE iPod Nano
If this lineup comes up with a computer language, intermediate or not, that is based on a hiearchical mark-up language for data only then I will probably decide there is no intelligent life on earth. Poor XML has a difficult enough time handling simple data that is non-hierachical. I could just see the stripped down mess an XML rendition of a HL would be.
Whilst i have no counter evidence, it seems unlikely that they'd be creating a copy of CIL.
Optimising high performance code distributed code has a different set of challenges to optimizing desktop or web applications. OGSA already provides a framework for grid applications to exist and communicatate in, and I suspect this already has some overlap with CIL.
I was begining to wonder if the pcode code concept was ever going to catch on - it's what, 35 years old now?
.sig
-- this is not a
The VB.NET implementation illustrates one of the central problems that low level IL seems to be subject to, as alluded to by the previous post. VB.NET is not Visual Basic, requiring a much higher degree of abstraction that many non-tech people (who generally make up the VB audience) find bewildering and cumbersome. It has the form that it has because the language had to be modified in order to work with the underlying .NET CLR, which eliminated many of the inherent advantages of VB in certain circumstances. This can be seen even more with the .NET versions of Perl, which has to sacrifice the highly flexible structure and run-time code construction in order to fit within the constraints of the IL (ditto for Javascript and other "interpreted" languages).
I suspect that the final IL will be XML based, though the encodings will likely be Post Schema Validated Infosets (PSVI) for performance. The idea that you can write a compiler in XSLT is perverse, but nonetheless really, really cool.
The simple fact it only runs on Windows -- seems to be a big hurdle. I think we can all just forget about holding our breath waiting for Micorsoft to port .Net to the CRAY platform.
The other reason Microsoft might not be invited to the party is the vast difference in Quality Control between Sun/Cray/IBM and Microsoft where testing is an After Thought, if it's done at all.
Aarggh -- if you're going to doing this, do it right:
So now it's considered a defeat or a "retreat" to create a new and improved version of one of your products?
.net." to be the most extreme sign of life possible. Honestly I wish they'd done it sooner.
Hey, I heard that Microsoft just released a new version of their OS and called it "Longhorn". cn I say "Ok, so now that WinXP is on the retreat they try to enter a new area?"
Personally, I would consider "Hm, Microsoft seems to be catching up to us. Let's make something better than current Java OR
Irritable, left-wing and possibly humorous bumper stickers and t-shirts
In all honesty, the XML would be generated at a level where hands would likely never touch it, more likely through a series of transformations. Having written XML generators for C++, C# and Java, I've found that the XML is, by itself, very verbose, because it is fundamentally a meta-level description. You wouldn't write:
<func optargn="burp">arg1 arg2 arg3 lst</func>
you'd write
<function name="foo">
<param name="arg1" type="xs:string"/>
<param name="arg2" type="xs:integer"/>
<param name="arg3" type="cplxOpj"/>
<param name="arg4" type="xs:string" optional="yes"/>
<!-- implementation code -->
</function>
In all likelihood, the fragment will have been generated via a UML interface or something similar, and this would then be produced through a simple transformation.
Before objecting to the cost involved, consider that both an XML parser and an XSLT transformation are fairly straightforward finite state machines, and could very easily be dropped into firmware (something that is already beginning to happen). Because of the ubiquity of XML, firmware processing of XML is making more and more sense, and once you have that, it becomes a natural for building ILs and related compiler technology.
Wasn't the Cray name bought from SGI a while back?
Over the last few decades, there have been many exotic parallel architectures. Dataflow machines, connection machines, vector machines, hypercubes, associative memory machines (remember LINDA?), perfect shuffle machines, random-interconnect machines, networked memory machines, and partially-shared-memory machines have all come and gone. Some have come and gone more than once. None has been successful enough to sell commercially in quantity. Very few of these machines have ever been purchased by any non-government entity.
There are two ends of the parallelism spectrum - the shared-memory symmetrical multiprocessor, where all memory is shared, and the networked cluster, where no memory is shared. Both are successful and widely used. Everything in between has been a flop.
Despite decades of failure, people keep coming up with new bad ways to hook CPUs together, and getting government agencies to fund them. It's more a pork program than a way to get real work done.
By the time one of these big wierdo machines is built, debugged, and programmed, it's outdated. A few years later, people are getting the same job done on desktops. Look at chess. In 1997, it took Deep Blue to beat Kasparov. Kasparov is now losing games to a desktop four-processor IA-32 machine.
Figuring out more effective ways to use clusters is far more cost effective than putting a National Supercomputer Center in some Congressman's district in Outer Nowhere. There's a whole chain of these tax-funded "National Supercomputer Centers". The "Alabama Supercomputer Center" has ended up as an ISP for the public school system, hosting E-mail accounts and such. It's all pork.
granted there is the 20 meg framework package, but really thats nothing these days
Tell that to somebody whose relatives live in an area where nobody offers high-speed Internet access for under $60 per month.
You're thinking the same thing I thought. As a compiler geek, when I hear "intermediate language," I think of exactly this same thing, a temporary representation of the code for checking and/or optimization purposes.
The more I thought about the (poorly-written) article, the more I think that perhaps they mean a new assembly language. Which from a viewpoint of the compiler, especially one like GCC, is not an intermediate language, but the final product. (Some compilers compile directly to machine code, essentially being both the compiler and the assembler, but those are often not portable/retargetable.
I posted about this earlier, but haven't seen a followup yet: which of these two is being proposed? Dunno yet.
You cannot apply a technological solution to a sociological problem. (Edwards' Law)
Formula for getting a story on /. follows:
:)
1. Link to an actual story.
2. Throw in lateset buzzwords (grid computing, XML, your choice!)
3. Don't sound completely illiterate (use four syllable words like ubiquitous).
Rinse, Repeat, Lather!
-Leo
Yes I do mean a jar to exe or elf or what ever it can be make support. This translates the java so no jit complier is required.
Think big please. Hundreds of thousands of threads, is not enough, we need millions, thousads of millions of threads.
The only way to get to this level is changing hardware. Current computers, are big memory pools with a single (logical) execution unit, that's the fault.
We need to build thousands of simpler executions units, and parallelization will be a real issue. Switching threads/process is not the answer.
On the software front, two musts for a new languaje: a) it should be 'aspect oriented' (flexible interception). b) automatic paralelization extracted at compile time from objects sets analisys.
Next sig please..
What's in a sig?
Putting corporate politics aside, what would be nice from a technical perspective is an intermediate language that is register-based. Microsoft decided to copy java so thoroughly they also copied java's mistakes by making the .NET runtime a stack machine. Market reality tells us Intel/AMD is not going away anytime soon, it would have been wise to make MSIL fit more nicely into the x86 architecture for performance purposes.
The mono/.DOTGNU projects are similarly unfathomable. It will be nice to have these tools available to run more bloated GUI's, but if one of these projects really wanted to differentiate itself, that project should instead focus on a C# to native-compiler using gcc's backend and let the other project focus on a compiler-to-MSIL. I guarantee you that project would become the 'winner'.
All of them have something to gain from a requirement of higher standard of computing power within businesses, and Sun has a history of bloating certain pacakges (Swing) to make them require a supercompuer for decent performancy.
Coincidentally, my new midrange server, used as a workstation, can run Swing with excellent responsiveness.
You can't judge a book by the way it wears its hair.
It seems you want assembler and C to disappear. Good Luck.. just choose your next OO language and move on.. thankyou..
OO does this.. OO does that.. OO does this.. hrm.. how is it executed.. oooh.. look its a REP STOS.. what the hell are you doing in there.. that CPU cant possibly know how to call that.. thats wrong.. wheres my OO.. I want my OO back..
Seems I picked up this thread pretty late. Was on a christmas hangonver. mmm .. anyway the idea seems like pulling us away from the concept of small and simple systems. Who would want to put a 20meg interpreter on a embedded device just to drive the byte codes. If it is for portability issue, there is still room for issue regarding that. Another crap after .net.
I hope they look into juice rather then doing yet another stack machine. Supposedly by using a tree structure as its intermediate rather then byte code more of the original intent of the program is preserved allowing for more powerful optimizations to be done by the jit.
that means fuck the gnaa can't you read you retarded fucking bastard
I posted this before, but it looks to me that this is still on topic here. How about making Java Free, openning it to new possibilities, optimizations etc.
----------
I would like to see GNU/Linux to become a more powerful platform and by a more powerful platform I mean a platform that provides the user with a pleasant experience. Now, to provide a pleasant experience a platform must give the user a choice - a choice of applications that exist for the platform is a step in the right direction. However, GNU/Linux is not such a platform yet. If it were, it would have been embraced by the masses already and it is not. There are a few things that GNU/Linux system is lacking and one of the more important lacking components is a convenient tool that allows a novice create his/her own software for the platform, software that easily manipulates data imported from multiple sources and allows to create graphical interfaces to that data. In the Microsoft this functionality is provided by such a ubiquitous tool as Visual Basic. In the Free Software world there are many tools that are extremely powerful but none of them have the same kind of momentum that Visual Basic delivers on Microsoft platform.
To answer the question- "What can be the VB for Free Software?" we need to look at the kind of problems that will have to be solved by this tool. The problems solved by VB are of many kinds, but for the general public VB provides the bridge that closes the gap between a user and a multitude of small problems that the user wants to solve. Of-course it is possible to just create a VB IDE for FS platforms but I believe there is a more interesting solution to this problem and it is Java. Just like VB, Java runs in a virtual machine, so the user will never really have direct access to any hardware resources, but an abstract layer of JVM can provide a nice buffer between the user and the hardware and at the same time Java will always behave in the same way on multiple other platforms, including Windows. Java has thousands of convenience libraries, there is enough Free Software written for Java that can be integrated into an IDE. However there is a big problem with the language itself - it is not Free.
Sun allows anyone to use Java for free but nobody can modify the language itself except for Sun. In order for Java to become for Free Software and Gnu/Linux what VB became for Microsoft, Java has to be Freed and put out under the GPL. There is also probably a good business sense in it for the Sun Microsystems as well - their language suddenly becomes the language of choice for millions and thousands will work on improving the language, the virtual machine, the compiler etc. In this case Sun will stay in a position that Linus finds himself in - they become the gate-keepers for the vanilla Java tree, but Java will branch and will become much more spread than it is right now. Sun can capitalize on that by providing more Java based solutions and services.
Now it is likely that Sun management will not agree to the change of their Java's status, however, if there was an immediately profitable reason for them to do this, they just may turn around and start thinking about it. A reason that is profitable could be a large sum of cash available to them upon releasing Java under the GPL. Where could this money come from? These money could be collected by the FS and OS supporters, the developers and the users who would like to see more momentum in the GNU/Linux movement towards a successful (wide spread) desktop solution. I suppose no one will seriously object to have one more powerful tool in their Free Software tool-bag. Java can be this tool and it can be just the thing needed to tip the scales over towards quick appearance of a useful and a popular GNU/Linux desktop.
You can't handle the truth.
It is a tribute to the Microsoft marketing department's vast prowess that so many clueless people think the .NET CLR has some magic voodoo which enables language interoperability in a way that the Java Bytecode and runtime cannot.
It is 100% unadulterated, pure, unfiltered BS. How did Microsoft do this? Does their marketing department have access to some magical artifact which endows them with these incredible powers? How do they manage to get the clueless moderated up to *5* repeating this dribble? Do they have secret moles buried deep in the Slashdot moderation system? One will never know.
Private Sub Form1_Load(
Excellent naming of your forms and variables!
- - - - - - - - - - -
I am a programmer. I am paid to produce syntax not grammar. Deal with it.
A little knowledge is a dangerous thing. There is a reason that we apply and peel off abstactions at different layers of the system. And no there is no need for reflection at the assembly level.
IBM has been doing work on this stuff for a while now. This is part of the point of the "on demand computing" initiative and is also related to "grid computing". If you can run your job on ANY computer then computing becomes more similar to a utility. You don't care/know what machine it runs on or even where it runs. It just gets done.
IBM has invested huge amounts of R&D into this already as well as quite a bit on marketing it.
So Sun's invitation to IBM and other to "join" them might be a way of trying to jump on IBM's bandwagon and benefit from work that IBM has already done. If IBM says no, then those who don't understand what is going on will think that IBM looks bad.
Lasers Controlled Games!
"Ah, well, since the knife is in anyway, I may as well twist it"? (-:
Got time? Spend some of it coding or testing
The Professor Jeff S Rohl not mentioned in most of the Pascal articles (possibly because he's more famous for Modula2 etc) lives about 20km south of here.
Got time? Spend some of it coding or testing
IRL: exit stage left, screaming. (-:
Got time? Spend some of it coding or testing
You forgot to mention that alongside the debugger, it has quite a bit of bugger factor built in. For example, only the very latest rendition of it can be construed to be OO. So that makes it an edit/bugger/compile/debug cycle.
The language is not the IDE. Tried KDevelop, GLADE, IDLE, Boa Constructor or any of the other FOSS IDEs recently?
Or, for that matter, Blender? (-:
Got time? Spend some of it coding or testing
Self-executing version bloats this to 37 bytes:
If you want that in a messageBox, you need to ramp it up to 153 bytes and add about one more meg of runtime. If you want it in 3D, add another 60kB of runtime, deeming OpenGL included.
So did I win this dick-shrinkage competition? (-:
Got time? Spend some of it coding or testing
The disk structure was very Forth. Can you imagine having to K)runch one of today's 300GB monsters every night?
Got time? Spend some of it coding or testing
thats great. really. but will it run on windows?
all the stuff I have to deal with has to run on windows, as well as access SQL databases, and things of that nature.
Show me how to do a SQL query in ruby, and then I will be impressed.
but sure, your hello world is slightly smaller than the first one I wrote on a 286 with borland C. congrats to you.
OOP based and XML format bytecode for supercomputers and it is equivalent to what kripton is for Superman
I understand that the runtime is slightly larger, and I'm not sure about the gtk/GL stuff, but Ruby in general is highly portable.
Got time? Spend some of it coding or testing
This IL obviously like many other things cannot be the best solution in all cases.
Which is why there generally are a million ways to solve each of the kazillion problems... each having its own plus points.
Its thus difficult to say that a universal intermediate runtime language for hi perf computing will emerge.
Even the design of a new computing architecture can render it ineffective (unless it is designed to avoid these issues, but then?) though ofcourse this doesnt happen overnight.
On the other hand ppl can even start making architecture specifically optimized for this language widely increasing its popularity. (speculation)>/p>
Look at what transmeta did in the crusoe. Adding another abstraction layer between the vliw cpu and the native x86 code had some very interesting results. As a matter of fact an IL could be even more useful in vliws when this arch gains popularity since optimization at the level of the IL maybe preferred over direct assembly(!) optimization in this case.
so imho this IL is not really going to be anything more than an interesting way to do high perf computing.
happy computing fellow nerds.
[all generalizations are untrue except this one]