Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.java.programmer > #9856 > unrolled thread

Java 8 Lambda binary snapshot

Back to article view | Back to comp.lang.java.programmer

Contents

  Java 8 Lambda binary snapshot markspace <-@.> - 2011-11-11 12:55 -0800
    Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-11 16:20 -0800
      Re: Java 8 Lambda binary snapshot markspace <-@.> - 2011-11-11 16:38 -0800
        Re: Java 8 Lambda binary snapshot Arved Sandstrom <asandstrom3minus1@eastlink.ca> - 2011-11-12 06:36 -0400
          Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-12 09:19 -0500
            Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-12 10:07 -0800
              Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-12 17:09 -0500
              Re: Java 8 Lambda binary snapshot Arved Sandstrom <asandstrom3minus1@eastlink.ca> - 2011-11-14 06:25 -0400
                Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-14 06:45 -0800
                  Re: Java 8 Lambda binary snapshot Robert Klemme <shortcutter@googlemail.com> - 2011-11-14 23:28 +0100
                  Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-15 20:34 -0500
                    Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-15 22:28 -0800
                      Re: Java 8 Lambda binary snapshot BGB <cr88192@hotmail.com> - 2011-11-16 07:43 -0700
                        Re: Java 8 Lambda binary snapshot kensi <kensi_kensington@zoonoses.de> - 2011-11-16 12:53 -0500
                          Re: Java 8 Lambda binary snapshot "Nasser M. Abbasi" <nma@12000.org> - 2011-11-16 12:20 -0600
                            Re: Java 8 Lambda binary snapshot BGB <cr88192@hotmail.com> - 2011-11-16 14:27 -0700
                              Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-16 14:04 -0800
                                Re: Java 8 Lambda binary snapshot BGB <cr88192@hotmail.com> - 2011-11-17 10:05 -0700
                      Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-16 18:57 -0500
          Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-12 09:23 -0500
      Re: Java 8 Lambda binary snapshot Roedy Green <see_website@mindprod.com.invalid> - 2011-11-13 09:12 -0800
        Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-13 12:39 -0500
          Re: Java 8 Lambda binary snapshot Andreas Leitgeb <avl@gamma.logic.tuwien.ac.at> - 2011-11-13 20:13 +0000
            Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-13 15:43 -0500
              Re: Java 8 Lambda binary snapshot Andreas Leitgeb <avl@gamma.logic.tuwien.ac.at> - 2011-11-13 21:06 +0000
                Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-13 16:16 -0500
          Re: Java 8 Lambda binary snapshot "Nasser M. Abbasi" <nma@12000.org> - 2011-11-14 08:03 -0600
            Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-14 06:51 -0800
    Re: Java 8 Lambda binary snapshot Roedy Green <see_website@mindprod.com.invalid> - 2011-11-12 04:53 -0800
    Re: Java 8 Lambda binary snapshot markspace <-@.> - 2011-11-12 14:02 -0800
      Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-12 17:09 -0500
        Re: Java 8 Lambda binary snapshot markspace <-@.> - 2011-11-12 19:14 -0800
          Re: Java 8 Lambda binary snapshot BGB <cr88192@hotmail.com> - 2011-11-12 20:56 -0700
          Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-13 05:08 -0800
          Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-13 10:08 -0500
            Re: Java 8 Lambda binary snapshot markspace <-@.> - 2011-11-13 08:08 -0800
              Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-13 12:23 -0500
          Re: Java 8 Lambda binary snapshot Roedy Green <see_website@mindprod.com.invalid> - 2011-11-13 09:23 -0800
            Re: Java 8 Lambda binary snapshot Arne Vajhøj <arne@vajhoej.dk> - 2011-11-13 12:27 -0500
            Re: Java 8 Lambda binary snapshot Lew <lewbloch@gmail.com> - 2011-11-13 11:08 -0800

Page 2 of 2 — ← Prev page 1 [2]

#9915

On Fri, 11 Nov 2011 16:20:03 -0800 (PST), Lew <lewbloch@gmail.com>
wrote, quoted or indirectly quoted someone who said :

>I look at Java closures as just syntactic sugar for anonymous interface implementations,
> and conversely, as anonymous interface implementations as a poor-man's closure.

You would do the Java community a great service by posting two
snippets:

one coded the Smith Barney way with anonymous classes and another with
a rough approximation to the new closures.
-- 
Roedy Green Canadian Mind Products
http://mindprod.com
I can't come to bed just yet. Somebody is wrong on the Internet. 

[toc] | [prev] | [next] | [standalone]

#9924

On 11/13/2011 12:12 PM, Roedy Green wrote:
> On Fri, 11 Nov 2011 16:20:03 -0800 (PST), Lew<lewbloch@gmail.com>
> wrote, quoted or indirectly quoted someone who said :
>
>> I look at Java closures as just syntactic sugar for anonymous interface implementations,
>> and conversely, as anonymous interface implementations as a poor-man's closure.
>
> You would do the Java community a great service by posting two
> snippets:
>
> one coded the Smith Barney way with anonymous classes and another with
> a rough approximation to the new closures.

Anonymous class:

         ArrayList<String> lst = new ArrayList<String>();
         lst.add("A");
         lst.add("BB");
         lst.add("CCC");
         Collections.sort(lst, new Comparator<String>() {
			public int compare(String s1, String s2) {
				return -s1.compareTo(s2);
			}
         });
         for(String s : lst) {
             System.out.println(s);
         }

Java 8 lambda:

import java.util.ArrayList;
import java.util.Collections;

public class Lambda {
     public static void main(String[] args) {
         ArrayList<String> lst = new ArrayList<String>();
         lst.add("A");
         lst.add("BB");
         lst.add("CCC");
         Collections.sort(lst, (s1,s2)-> -s1.compareTo(s2));
         for(String s : lst) {
             System.out.println(s);
         }
     }
}

Arne

[toc] | [prev] | [next] | [standalone]

#9932

Arne Vajhøj <arne@vajhoej.dk> wrote:
> 			public int compare(String s1, String s2) {
> 				return -s1.compareTo(s2);
> 			}

I'd use   s2.compareTo(s1) instead, to prevent the problem
of -Integer.MIN_VALUE < 0

>          Collections.sort(lst, (s1,s2)-> -s1.compareTo(s2));

Really? Without specifying types for s1 and s2? Looking forward to it...

[toc] | [prev] | [next] | [standalone]

#9935

On 11/13/2011 3:13 PM, Andreas Leitgeb wrote:
> Arne Vajhøj<arne@vajhoej.dk>  wrote:
>> 			public int compare(String s1, String s2) {
>> 				return -s1.compareTo(s2);
>> 			}
>
> I'd use   s2.compareTo(s1) instead, to prevent the problem
> of -Integer.MIN_VALUE<  0

Good point.

>>           Collections.sort(lst, (s1,s2)->  -s1.compareTo(s2));
>
> Really?

Yes.

> Without specifying types for s1 and s2?

Types inferred.

> Looking forward to it...

You can download the early access kit now and play with it.

This specific example did compile and run fine.

Arne

[toc] | [prev] | [next] | [standalone]

#9937

Arne Vajhøj <arne@vajhoej.dk> wrote:
> On 11/13/2011 3:13 PM, Andreas Leitgeb wrote:
>> Arne Vajhøj<arne@vajhoej.dk>  wrote:
>>>           Collections.sort(lst, (s1,s2)-> s2.compareTo(s1)); [mod]
>> Really?
> Yes.

Cool!

>> Looking forward to it...
> You can download the early access kit now and play with it.

Wouldn't help me for my current projects, though... :-(

[toc] | [prev] | [next] | [standalone]

#9940

On 11/13/2011 4:06 PM, Andreas Leitgeb wrote:
> Arne Vajhøj<arne@vajhoej.dk>  wrote:
>> On 11/13/2011 3:13 PM, Andreas Leitgeb wrote:
>>> Arne Vajhøj<arne@vajhoej.dk>   wrote:
>>>>            Collections.sort(lst, (s1,s2)->  s2.compareTo(s1)); [mod]
>>> Really?
>> Yes.
>
> Cool!
>
>>> Looking forward to it...
>> You can download the early access kit now and play with it.
>
> Wouldn't help me for my current projects, though... :-(

No - you will need to wait minimum 1-2 years - longer if
it is one of those cases where upgrades are considered
as fun as getting teeth pulled out at the dentist.

Arne

[toc] | [prev] | [next] | [standalone]

#9954

On 11/13/2011 11:39 AM, Arne Vajhøj wrote:

> Java 8 lambda:
>
> import java.util.ArrayList;
> import java.util.Collections;
>
> public class Lambda {
>       public static void main(String[] args) {
>           ArrayList<String>  lst = new ArrayList<String>();
>           lst.add("A");
>           lst.add("BB");
>           lst.add("CCC");
>           Collections.sort(lst, (s1,s2)->  -s1.compareTo(s2));
>           for(String s : lst) {
>               System.out.println(s);
>           }
>       }
> }
>
> Arne
>

ps. I just heard about this Lambda thing ;)

This looks like the ability to have, what is called in Mathematica,
or may be other functional languages, a pure function, that one
can define and use on the fly ?

For example, in Mathematica, one can write

"Sort[list,p]
sorts using the ordering function p. "

and is coded like this, for example:

In[11]:= Sort[{4,1,3,2,2},#1>#2&]
Out[11]= {4,3,2,2,1}

where the '&' indicates the end of the function, and
#1 means first argument, and #2 mean the second argument.

One can also write the pure function more explicit, like this:

In[8]:= Sort[{4,1,3,2,2},Function[{x,y},x<y]]
Out[8]= {1,2,2,3,4}

Is this, somewhat,  close to what Lambda in Java allows?

It is very useful feature to be able to do this sort of thing.
(I need to read more about Java 8, sounds interesting)

--Nasser

[toc] | [prev] | [next] | [standalone]

#9956

 Nasser M. Abbasi wrote:
> ps. I just heard about this Lambda thing ;)

"This Lambda [sic] thing" has been around longer than the Java language.

> This looks like the ability to have, what is called in Mathematica,
> or may be other functional languages, a pure function, that one
> can define and use on the fly ?
> 
> For example, in Mathematica, one can write
> 
> "Sort[list,p]
> sorts using the ordering function p. "
> 
> and is coded like this, for example:
> 
> In[11]:= Sort[{4,1,3,2,2},#1>#2&]
> Out[11]= {4,3,2,2,1}
> 
> where the '&' indicates the end of the function, and
> #1 means first argument, and #2 mean the second argument.

This has existed in Java since about version 1.1, only the syntax is rather more verbose.

They don't call it "pure function" in Java; there is no such thing.  It's called "implementation of a callback interface" in Java.

The "lambda" feature of Java 8 is a syntactic sweetener of the interface-implementation idiom, not the addition of "pure" (whatever that means) functions.

> One can also write the pure function more explicit, like this:
> 
> In[8]:= Sort[{4,1,3,2,2},Function[{x,y},x<y]]
> Out[8]= {1,2,2,3,4}
> 
> Is this, somewhat,  close to what Lambda in Java allows?

Why not read the literature, cited at the top of this thread?  That question was answered from the very start of this conversation.  Of course, it does require that you actually click to and read the information.

OTOH, documentation is a wonderful thing, and the habit of studying it a most empowering one.

Try it, why don't you?

> It is very useful feature to be able to do this sort of thing.
> (I need to read more about Java 8, sounds interesting)

Yes - yes you do.

-- 
Lew

[toc] | [prev] | [next] | [standalone]

#9872

On Fri, 11 Nov 2011 12:55:08 -0800, markspace <-@.> wrote, quoted or
indirectly quoted someone who said :

>Lambda dev and the compiler group (and possibly others) published a 
>binary snapshot of the current state of lambdas and closures for Java.
>
>http://jdk8.java.net/lambda/

I was just updating the summaries for the various JDK versions, and I
realised I do know the code names for Java 8 and 9.  7 was split in
two, so it may also be called dolphin.

Anyone know?

see http://mindprod.com/jgloss/jdkreleasedates.html
-- 
Roedy Green Canadian Mind Products
http://mindprod.com
Windows is a case-insensitive operating system,
but that does not mean you can forget about case. 
For example, Let us assume you have a file called
Abc.txt in C:\temp, and a file called 
aBc.txt in D:\temp and you type 
copy C:\temp\abC.txt D:\temp. What is the name of the file in 
D:\temp when you are done?
1) Abc.txt 2) aBc.txt 3) abC.txt 4) abc.txt 5) ABC.txt
Hint, the answer rhymes with the most popular word in advertising. 

[toc] | [prev] | [next] | [standalone]

#9884

On 11/11/2011 12:55 PM, markspace wrote:
> Lambda dev and the compiler group (and possibly others) published a
> binary snapshot of the current state of lambdas and closures for Java.
>
> http://jdk8.java.net/lambda/


One note: it seems much of the compiler is there, but that the JVM is 
lagging behind and can't execute some of the compiler output.  This 
seems to further imply we are loosing backwards binary compatibility 
with Java 8.  I don't know how significant that is.

[toc] | [prev] | [next] | [standalone]

#9885

On 11/12/2011 5:02 PM, markspace wrote:
> On 11/11/2011 12:55 PM, markspace wrote:
>> Lambda dev and the compiler group (and possibly others) published a
>> binary snapshot of the current state of lambdas and closures for Java.
>>
>> http://jdk8.java.net/lambda/
>
>
> One note: it seems much of the compiler is there, but that the JVM is
> lagging behind and can't execute some of the compiler output. This seems
> to further imply we are loosing backwards binary compatibility with Java
> 8. I don't know how significant that is.

What??

Requiring a Java 7 java to execute Java 8 javac output is forward
compatible not backward compatible.

And AFAIK then Java has never promised or intended being
forward compatible.

Arne

[toc] | [prev] | [next] | [standalone]

#9897

On 11/12/2011 2:09 PM, Arne Vajhøj wrote:

> Requiring a Java 7 java to execute Java 8 javac output is forward
> compatible not backward compatible.


Hmm, I guess I was thinking of "Java 8 is not backwards compatible with 
Java 7 JVM," although there may be subtleties to that term that I'm not 
understanding.


> And AFAIK then Java has never promised or intended being
> forward compatible.


My main goal was to point out to folks here who may try that snapshot 
that "it's not all there yet" so they didn't spend too much time 
spinning their wheels if they found something that didn't run.  Likely, 
it's the JDK that probably isn't 100% yet, not the coder.

[toc] | [prev] | [next] | [standalone]

#9898

On 11/12/2011 8:14 PM, markspace wrote:
> On 11/12/2011 2:09 PM, Arne Vajhøj wrote:
>
>> Requiring a Java 7 java to execute Java 8 javac output is forward
>> compatible not backward compatible.
>
>
> Hmm, I guess I was thinking of "Java 8 is not backwards compatible with
> Java 7 JVM," although there may be subtleties to that term that I'm not
> understanding.
>

the Java 7 JVM is not forwards-compatible with Java 8 bytecode.

Java 8 would fail to be backwards compatible if it failed to run apps 
compiled with the Java 7 JDK or earlier (which is not likely something 
Oracle would do).

this is because the Java 7 JVM is what is running the bytecode, not the 
other way around.


people put much effort into making sure old stuff keeps working, but 
expecting future stuff to also work is not really a workable goal (the 
best one can generally do is try to design things such that they can be 
extended gracefully and breaking as little as possible in the process).

so, maybe forwards compatibility comes in a few levels (nothing formal 
here, just categorization):
level 0: stuff blows up catastrophically due to the changes (in an 
unpredictable way, such as the program crashing or running out of control);
level 1: the unrecognized data is rejected with an error status or message;
level 2: what is recognized is handled, but the program "gracefully 
fails" regarding unrecognized data (any new features are missing, but 
everything else works mostly as expected);
level 3: everything works correctly somehow.

level 1 and 2 are probably most common.


>
>> And AFAIK then Java has never promised or intended being
>> forward compatible.
>
>
> My main goal was to point out to folks here who may try that snapshot
> that "it's not all there yet" so they didn't spend too much time
> spinning their wheels if they found something that didn't run. Likely,
> it's the JDK that probably isn't 100% yet, not the coder.
>

[toc] | [prev] | [next] | [standalone]

#9906

markspace wrote:
> Arne Vajhøj wrote:
> 
>> Requiring a Java 7 java to execute Java 8 javac output is forward
>> compatible not backward compatible.
> 
> Hmm, I guess I was thinking of "Java 8 is not backwards compatible with 
> Java 7 JVM," although there may be subtleties to that term that I'm not 
> understanding.

Code emitted by a Java 5 compiler will not run on a Java 1.4 JVM (unless you specify "-target" and "-bootclasspath", and not always then).  Likewise with Java 6 class files trying to run in a Java 5 JVM.  Java 1.2 wouldn't run on a 1.1 JVM.  It has always been thus.

>> And AFAIK then Java has never promised or intended being
>> forward compatible.

Whatever you call it, the code emitted by the more advance compiler naturally cannot guarantee to run on the older platform.


> My main goal was to point out to folks here who may try that snapshot 
> that "it's not all there yet" so they didn't spend too much time 
> spinning their wheels if they found something that didn't run.  Likely, 
> it's the JDK that probably isn't 100% yet, not the coder.

Even if the JDK were "100%", it would still need a compatible JVM to run it.

Just like always.

-- 
Lew

[toc] | [prev] | [next] | [standalone]

#9909

On 11/12/2011 10:14 PM, markspace wrote:
> On 11/12/2011 2:09 PM, Arne Vajhøj wrote:
>> Requiring a Java 7 java to execute Java 8 javac output is forward
>> compatible not backward compatible.
>
> Hmm, I guess I was thinking of "Java 8 is not backwards compatible with
> Java 7 JVM," although there may be subtleties to that term that I'm not
> understanding.
>
>> And AFAIK then Java has never promised or intended being
>> forward compatible.
>
> My main goal was to point out to folks here who may try that snapshot
> that "it's not all there yet" so they didn't spend too much time
> spinning their wheels if they found something that didn't run. Likely,
> it's the JDK that probably isn't 100% yet, not the coder.

A simple example worked for me.

And it looks as if the compiler actually generates an anonymous class
similar to the traditional way.

Arne

[toc] | [prev] | [next] | [standalone]

#9910

On 11/13/2011 7:08 AM, Arne Vajhøj wrote:

> And it looks as if the compiler actually generates an anonymous class
> similar to the traditional way.


Despite posting it here I haven't got a chance to try it myself yet!  Do 
you mean the compiler generates anonymous classes for lambdas?  Because 
I thought they were using invoke-dynamic for that, which was the 
incompatibility issue.

If you mean just an anonymous class that the coder declares, then yes I 
doubt that will change.

[toc] | [prev] | [next] | [standalone]

#9918

On 11/13/2011 11:08 AM, markspace wrote:
> On 11/13/2011 7:08 AM, Arne Vajhøj wrote:
>
>> And it looks as if the compiler actually generates an anonymous class
>> similar to the traditional way.
>
>
> Despite posting it here I haven't got a chance to try it myself yet! Do
> you mean the compiler generates anonymous classes for lambdas? Because I
> thought they were using invoke-dynamic for that, which was the
> incompatibility issue.
>
> If you mean just an anonymous class that the coder declares, then yes I
> doubt that will change.

C:\Work>dir Lambda*.*
  Volume in drive C is ARNEPC4
  Volume Serial Number is F878-3B24

  Directory of C:\Work

11/11/2011  07:50 PM               410 Lambda.java
                1 File(s)            410 bytes
                0 Dir(s)  939,431,432,192 bytes free

C:\Work>\sun\64bit\lambda-8-b1314-windows-x64-10_nov_2011\bin\javac 
Lambda.java

C:\Work>dir Lambda*.*
  Volume in drive C is ARNEPC4
  Volume Serial Number is F878-3B24

  Directory of C:\Work

11/13/2011  12:22 PM               678 Lambda$1.class
11/13/2011  12:22 PM               929 Lambda.class
11/11/2011  07:50 PM               410 Lambda.java
                3 File(s)          2,017 bytes
                0 Dir(s)  939,431,399,424 bytes free

Arne

[toc] | [prev] | [next] | [standalone]

#9919

On Sat, 12 Nov 2011 19:14:53 -0800, markspace <-@.> wrote, quoted or
indirectly quoted someone who said :

>Hmm, I guess I was thinking of "Java 8 is not backwards compatible with 
>Java 7 JVM," although there may be subtleties to that term that I'm not 
>understanding.

There are two kinds of compatibility.  Old programs continue to run on
new hardware or JVMs.  Is that Forward or Backward compatibility?  I
have heard people use both terms.

The other is new programs written carefully with new tools to avoid
using new features will run on old hardware and JVMs.

Is that Forward or Backward compatibility?  or something else?

IBM salesmen loved to talk about upward and downward compatibility. 
The IBM mainframers were very serious about ensuring even extremely
old code would continue to run, even if it took multiple layers of
emulation. 1410 emulation was still running in the 1990s, long after
1410 boxes lived only in museums.  Again, I am not sure what they
meant by the terms. I think they used them synonyms for "good" and
"reliable".

If there is a consensus, I will do a entry in the glossary on the
matter.

-- 
Roedy Green Canadian Mind Products
http://mindprod.com
I can't come to bed just yet. Somebody is wrong on the Internet. 

[toc] | [prev] | [next] | [standalone]

#9920

On 11/13/2011 12:23 PM, Roedy Green wrote:
> On Sat, 12 Nov 2011 19:14:53 -0800, markspace<-@.>  wrote, quoted or
> indirectly quoted someone who said :
>
>> Hmm, I guess I was thinking of "Java 8 is not backwards compatible with
>> Java 7 JVM," although there may be subtleties to that term that I'm not
>> understanding.
>
> There are two kinds of compatibility.  Old programs continue to run on
> new hardware or JVMs.  Is that Forward or Backward compatibility?  I
> have heard people use both terms.
>
> The other is new programs written carefully with new tools to avoid
> using new features will run on old hardware and JVMs.
>
> Is that Forward or Backward compatibility?  or something else?

http://en.wikipedia.org/wiki/Backward_compatibility
http://en.wikipedia.org/wiki/Forward_compatibility

Arne

[toc] | [prev] | [next] | [standalone]

#9928

Roedy Green wrote:
> IBM salesmen loved to talk about upward and downward compatibility. 
> The IBM mainframers were very serious about ensuring even extremely
> old code would continue to run, even if it took multiple layers of
> emulation. 1410 emulation was still running in the 1990s, long after
> 1410 boxes lived only in museums.  Again, I am not sure what they
> meant by the terms. I think they used them synonyms for "good" and
> "reliable".
> 
> If there is a consensus, I will do a entry in the glossary on the
> matter.

Backward compatibility is when the new platform runs old code, just as those serious IBM mainframers promised.  In other words, it's when the Java 8 platform runs Java 7- code.  Forward compatibility is when new code runs on the old platform, just as neither IBM nor Java have ever promised.  Never.

The complaint was that Java 8 code doesn't run under Java 7.  That's forward compatibility.  Java 7 doesn't run under 6, 6 doesn't run under 5, 5 doesn't run under 1.4, just try running code with an 'assert' under Java 1.3, forget about using 'ArrayList' in Java 1.1!

Ooh, surprise!  New features don't run on old engines!  File a bug!

It's never been different.

-- 
Lew

[toc] | [prev] | [standalone]

Page 2 of 2 — ← Prev page 1 [2]

Back to top | Article view | comp.lang.java.programmer

csiph-web