Java Trial Support Coming In Linux Standard Base
LinuxScribe writes "Java isn't in the LSB — yet. It's been a hard target to hit: which version gets standardized? How will test suites work? But the new version of LSB will take the first steps towards Java inclusion in standardized Linux development by introducing trial support for the language."
The LSB still doesn't make much in the way for accommodations for source-based distros. And while I laud its efforts, the LSB also states that distros should standardize on RPMs where as the one distro taking off like a rocket is DEB based and unlikely to ever move over to RPMs.
http://blindscribblings.com - Tasty pop-culture in conceptual fashion.
I for one do not welcome any new Java judicial overlords or any other sort of Java-based justice systems.
I can fucking run browser applets on 64-bit Linux?
So annoying... home is dual 32-bit so I can run TD Ameritrade with no problems---it flies.
Then at work which is quad-64 bit, in order to get any java applets to work I'd have to bastardize my browser down to 32-bit so nsplugin can launch them---and when OpenSuSE releases an update on YaST--it blows this setup away since it sees "aha, you're on 64-bit, buddy!"
Sun not supporting 64-bit applets in their runtime is a travesty. Fix it!
OBJECTION!
Bow-ties are cool.
---based off N number of JREs (FOSS, IBM, Sun)...
---on N number of distributions
---who use N number of package management systems, that package software in
---N number of archive formats
Yeah, this is a cakewalk.
If you're looking for a locked down, certified, guaranteed lowest-common-denominator Linux platform, why not go with Java 1.4.2? Even though (because) it's end-of-lifed, it's not going to change, Sure, it's got language incompatibility issues with 1.5, but it's a well-known item. Test and certify your Java app for LSB on 1.4.2 and you know the platform isn't going to change under you.
No folly is more costly than the folly of intolerant idealism. - Winston Churchill
They should really try to keep the linux base as small as possible. The point is to increase compatibility by creating a standard to which everyone codes. If they throw everything and the kitchen sink in the standard, that kind of defeats the whole point. Everyone will just keep on coding however they want, and a basic LSB compliant distro will become ever more bloated.
I know it's hard work to get everyone to agree on what really needs to be in the base, but if you're not going to do that hard work, why have a standard base at all?
Give me Classic Slashdot or give me death!
Ahhh, jealous of the garbage collection, and tempted by the C-like syntax, are we? :)
Fear not, fellow camel-caser, Linux already has Binary Kernel Support for Linux!
If I mod you up, it doesn't necessarily mean I agree with what you've said, sorry.
I see it from 2 angles:
*) Linux is so easy to develop for because it comes with a C compiler
*) Java is the language all of the schools teach
To keep new programmers interested in linux, java should be a standard (or at least easy) part of linux distros moving forward.
Experienced users can delete it if they don't want the bloat of it.
Next step, take the butt-ugly out of the java gui widgets.
Should we abandon LSB and embrace chaos, or should we try to make it work? Just because people are not adhering 100% to a standard, that does not make it useless or irrelevant. Look at SQL or even POSIX.
Anyone can whine about perceived problems. What do you think should be done to fix LSB?
I do not welcome any judicial overlords telling me which language to use or not use. I want EVERY language in common use to be available.
There IS a standard for Java functionality. It is rather inclusive. Developers can write Java applications using advanced features such as JNI without regard to the JRE's author. It matters not which JVM provides the functionality.
Standards can be written, and ARE written, so that there is both flexibility where necessary, and rigor, where required.
The only Java implementation released under the GPL is 1.6.
I think that's a pretty overwhelming reason.
GNU java is not java, it has not passed the tests. It does not even begin to work with the stuff I use at work.
Third-party vendors really like it when there a real, Sun-certified java implementation available as /usr/bin/java. It makes installation and deployment MUCH simpler.
Java app vendors see Linux as just another platform. This puts Linux in the same league as Solaris as far as they are concerned.
But the standard can stipulate how they are to be implemented IF they are implemented. Nobody is suggesting that a $5 linux chip HAS to have a full JVM installed on it.
Unlike mono.
Java is standard in ways that mono will never be.
"Anonymous Coward" is a really accurate description of your attitude.
Yes, you are mistaken about there being a standard way to run java on Linux. This is EXACTLY what LSB is for.
If you, Anonymous Coward, want to put mono in the LSB, then get started and present a proposal.
We have nothing else. POSIX is insufficient. We need LSB. It needs to work. Even in its current state it keeps Linux from turning into a nebulous mess.
What? That's simply not true. An emulator is a program that imitates a piece of hardware in order to execute programs originally intended to run on the hardware. Which is exactly what the Java VIRTUAL MACHINE (JVM) does.
Programming languages hide hardware details using abstraction, but they don't emulate anything.
I guess he's not the only one.
Maybe not
Perl is a program that imitates a piece of hardware, too. Just it because it doesn't happen to exist doesn't mean that it's not an emulator.
From vi,
1,$s/\(.\)\(.\)/\2\1/g
will yield a copy of your file which looks disturbingly different.
Doing the command again, will yield the original file.
For even more confusion, try :
1,$s/\(.\)\(.\)\(.\)/\3\2\1/g
Repeat and rinse as necessary...
There's a gorilla from Manilla whose a fella that stinks of vanilla and has salmonella.
1. Don't use your subject field as a discussion field. Use the post body. This goes for your parent as well.
2. Don't you mean "EXCEPTION!?"
1: I didn't.
2: No.
Bow-ties are cool.
The LSB really needs to change it's position as a pre-installed program enforcer to a normal standards body. Standards bodies should not try to make users have certain programs installed by default, they should promote and help out with the APIs for software that is common, has great potential, and popular, or otherwise where it's needed. They should be vying for program interoperability. Then, if I need a newer version of Java to be installed, or another simultaneous version to be installed, or whatever I want, I can do that using dependencies and and as long as I have the freedom to easily install any Java package I want to. Then, why bother making it's existence a standard? If it is good, and it's something users want, they will come.
The LSB should really take a chapter from the pages of the Free Desktop, W3C, or other standards bodies that actually function well and help provide that program interoperability.
What's that? I ran iotop but it's not installed, but I can run apt-get install iotop to get it? Gosh, that's difficult, I dunno if I can handle doing that with all those letters and commands and shit. If you want a certain program to come default in your installs, that's what rolling your own "distro" is for, not that there aren't a hundred other methods of software deployment you can use.
Promote true freedom - support standards and interoperability.
Why your argument has no merit:
Java bytecode serves the same purpose as any typical CPU architecture's bytecode. An X86 C compiler is compiled into x86 bytecode, and 'Java' compiler's create Java bytecode. The large difference is that Java bytecode requires a lot more behind-the-scenes CPU constructs that must be implemented in software for lower level architectures.
By your presupposition, X86 C is an emulation, because a programmer doesn't see/control memory segments? Because memory mapped I/O is more or less magic to the non-kernel developer?
LSB is all about determining the standard development and runtime standards so that for instance my C program's "long long" is always going to be 8 bytes.
LSB adopting a standard for java implementations means that the java runtime (or native coprocessor) supported by the an OS will implement the runtime in the same way as any other Java LSB implementer.
Sun all but controls the java spec, so there's little worries of implementation divergence, but its a nice symbolic gesture to say hey, we think of Java as a first class citizen of the OS, and not some tack-on afterthought that many distributions (read: all of them) implement poorly today.
Finally, LSB covers a large number of architectures, but I'm pretty sure that most of the member groups don't support or care about many of them, like the S390 for instance. Just because Java is mentioned in the spec, it doesn't mean that every LSB implementer will use java. What I 'hope' it'll mean is that every Java implementer will do it in a compatible way.
Bye!
You're confused. I'm not arguing for or against Java in the LSB. I don't even care.
I was just pointing out that the statement "Every language is an emulator" is false. Every language is an abstraction layer over hardware, but the phrases "abstraction layer" and "emulator" are not the same thing.
If it's involved at all, emulation would be an (unnecessary) implementation detail.
Maybe not
You're confusing programming languages with their implementations.
Your statement:
just isn't true.
A programming language is an abstraction that hides hardware details, while "emulator" is a well defined word meaning "a piece of software or hardware that executes programs meant for another piece of hardware".
Some language implementations use emulation, but it's not a requirement - it's an implementation detail. It's not even a requirement for the two languages you mentioned. There are Java compilers that compile straight to native code, and there are ways of getting native code from Perl.
Maybe not
Java bytecode format is also specified, and that spec is an integral part of the whole Java-the-platform thing. It's not an implementation detail.
Yes it is. There's a difference between "Java-the-platform" and "Java-the-language". Java byte-code and the JVM are part of Sun's Java platform - not part of the language.
There are Java compilers that do not emit bytecode for a JVM.
Maybe not
Imagining a virtual machine helps explain the abstraction provided by the language. But that doesn't make the language an emulator. It doesn't even make sense that you'd jump to that conclusion.
It's not fucking rocket science.
Maybe not
They are not part of Sun's Java platform. They are part of anything that can call itself Java (because Sun still controls the trademark, and using JVM bytecode is a requirement to use it). Which is why GCJ ,BEA, IBM and other Java implementations all also use the same bytecode format, and Java classes compiled by them all are interchangeable.
GCJ working in a native mode is not a Java compiler. It's a compiler of a language that is 100% Java-compatible, but it's not a Java implementation (because Sun says so).
You're missing the point. There's a difference between the implementation and the language. Sun requires all Java implementations be compatible with theirs in order to use the "Java" trademark. And their implementation uses a virtual machine (emulator). But there's nothing inherent in the Java language itself that requires using a virtual machine. It's a purely artificial requirement put on by Sun in order to use their trademark. It's an implementation detail.
It's irrelevant anyway, because even for Sun's Java platform, the virtual machine is the emulator, not the language itself. So the OP's statement is still stupid. If he had said "Any language can be compiled to run on an emulator," or something like that, I would never have even said anything. But his statement "All languages are emulators," is simply incorrect.
Now you're just being ridiculous. Just because "Sun says so" doesn't make it not a Java compiler. They can't legally call it a Java compiler, but that doesn't change the fact that it is one. If Sun told you the sky was green, would you believe that too?
Maybe not
Java-the-language is specified in the Java Language Specification. Part of that specification covers runtime behavior - and that part explicitly uses terms such as "Java virtual machine", "verification", "class loader" etc. So, yes, the Java language specification mandates certain library and runtime facilities - such as class loaders - that must be able to e.g. dynamically load a Java class from a stream with bytecode in proper (specified) format.
Fine, think of it this way: I can build a processor that directly executes Java byte code, therefore it wouldn't require a software implementation of the JVM, and so wouldn't be running in an emulator. Making the OP's "Every programming language is an emulator" statement false, even for Java.
I don't even know why you're wasting your time arguing about this. The issue was the truth of the statement "Every programming language is an emulator," not whether Java requires a virtual machine. It's fairly obvious that you recognize that the JVM is the emulator and not the actual language itself.
Maybe not
Every computer simulates a Turing machine.
Discuss.