Java-Gaming.org    
Featured games (81)
games approved by the League of Dukes
Games in Showcase (499)
Games in Android Showcase (118)
games submitted by our members
Games in WIP (568)
games currently in development
News: Read the Java Gaming Resources, or peek at the official Java tutorials
 
    Home     Help   Search   Login   Register   
Pages: 1 [2] 3 4 ... 6
  ignore  |  Print  
  Java 7 to get Closures!  (Read 22158 times)
0 Members and 1 Guest are viewing this topic.
Offline Orangy Tang

JGO Kernel


Medals: 56
Projects: 11


Monkey for a head


« Reply #30 - Posted 2009-11-20 09:52:22 »

Aye, there's a definite friction now between people who want shiny buzzword compliant features and those who appreciate java's clean and minimal syntax. It's very close to the Perl vs. Python philosophies IMHO.

It certainly seems that since C# appeared there's some language envy going on which has resulted in Java copying some of C#'s features in a cack-handed way. At least this doesn't seem to be as edge-case-ridden as generics, but you never know...

[ TriangularPixels.com - Play Growth Spurt, Rescue Squad and Snowman Village ] [ Rebirth - game resource library ]
Offline DzzD
« Reply #31 - Posted 2009-11-20 10:33:25 »

IMHO simpliciy make powerness in all computer area : OS, software & ibraries, and of course languages and more .... When trying to handle everythink in a single entity all become bug source / slow and more ....

cf : javafx, word, windows, eclipse etc...

Offline Markus_Persson

JGO Wizard


Medals: 15
Projects: 19


Mojang Specifications


« Reply #32 - Posted 2009-11-20 12:34:14 »

So, if I understand this correctly, # would basically be an anonymous function, which gets compiled into an anonymous class that only has that function, implementing some interface?
Isn't this just tacking more fake stuff onto the language that it wasn't designed for in the first place?

Play Minecraft!
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline bienator

Senior Member




OutOfCoffeeException


« Reply #33 - Posted 2009-11-20 12:36:32 »


Online kevglass

JGO Kernel


Medals: 172
Projects: 23
Exp: 18 years


Coder, Trainee Pixel Artist, Game Reviewer


« Reply #34 - Posted 2009-11-20 12:53:47 »

How typically "clever" Smiley

Kev

Offline princec

JGO Kernel


Medals: 391
Projects: 3
Exp: 16 years


Eh? Who? What? ... Me?


« Reply #35 - Posted 2009-11-20 13:04:08 »

The warning bell is the use of an annotation to change the behaviour of variables outside the scope of the lambda function. That and the use of the # symbol. I mean, really. Tsk.

Cas Smiley

Offline xinaesthetic

Senior Member


Medals: 1



« Reply #36 - Posted 2009-11-20 13:40:03 »

I've just implemented the derivative example from http://en.wikipedia.org/wiki/First-class_function in Java with anonymous classes, and I'm now prepared to admit that the current syntax is clear and perfect, while adding first class functions would probably make our collective heads asplode.
1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
15  
16  
17  
18  
19  
20  
21  
22  
23  
24  
25  
26  
27  
28  
29  
30  
31  
interface Fun {
   public double fun(double v);
}

interface HighFun {
   public Fun hiFun(Fun f, double v);
}
public class DerivativeFun {
   public static void main(String[] args) {
      Fun cos = new HighFun() {
         @Override
         public Fun hiFun(final Fun f, final double dx) {
            return new Fun(){
               @Override
               public double fun(double x) {
                  return (f.fun(x+dx) - f.fun(x)) / dx;
               }
            };
         }
      }.hiFun(new Fun(){
         @Override
         public double fun(double v) {
            return Math.sin(v);
         }
      }, 0.000000001);
     
      System.out.println("cos(0) = " + cos.fun(0));
      System.out.println("cos(PI/2) = " + cos.fun(Math.PI / 2));
   }

}

What a refreshing change from Javascript / Scala / C#.


Now, this is admittedly a contrived example... and far from usable (I leave making it generic as an exercise to the reader Wink).  It also doesn't actually get the closure thing to happen properly, in fact I don't see how that's possible in this case without inventing a special double wrapper class and doing the maths on that with special methods or something, since mutating a primitive referred to in several places won't happen.

Please someone point out what I'm missing here.




What's clean and minimal about that?  Just make functions first class types and they can fit consistently with the rest of the syntax.  I admit that the # and use of annotation do smell a bit fishy.

The thing is, it seems simplicity in one dimension frequently entails complexity in another; make an operating system appear* simple to use, you often need to introduce more sophisticated technology to facilitate it.

To make a programming language able to express certain things neatly at a high level, it can serve to complicate the language.  Of course great care needs to be taken to prevent this from backfiring... but I don't think avoiding closures is an example where they're better off being left out.

IMHO it's just the nature of progress that we build higher level abstractions, which tends to have the effect of hiding exponentially increasing amounts of complexity.  When these levels are hidden behind an abstraction, then there's the chance of the underlying implementation being improved while the interface remains identical.

Personally, I'd love to see something like LINQ in Java (provided it was well implemented)... but at least I can appreciate that really would complicate the syntax.

If you really want a simple, consistent, syntax... you could always use Lisp (maybe Clojure). Smiley

* [EDIT: I had accidentally inserted the word 'appear' in the middle of 'operating system', rather than after...]
Offline OverKill

Junior Member




Java games rock!


« Reply #37 - Posted 2009-11-20 16:28:01 »

I don't see the point. What's the problem with just declaring a private class? At least then you know what's going on.

Agree 100%
People have no problems creating complicated overblown designs but create an annon inner class.. OMG.. this is too much!

The problem is that a bunch of smartypants types who have been programming for years think it'd be great to add this fancy new feature to Java to make it look even more complicated than it really needs to be, and so the original goal of Java ("C++ without the knives, guns, and clubs") is going to be completely lost.

I had to debug some C++ code yesterday. If it ends up looking like that ... well, I'll get me coat.

Cas Smiley
Personally I think it is just people wanting to add a new feature every day.

I think Java needs more improvement, but not this way.

It certainly seems that since C# appeared there's some language envy going on which has resulted in Java copying some of C#'s features in a cack-handed way. At least this doesn't seem to be as edge-case-ridden as generics, but you never know...
Nearly, I think it is less language envy, but more the pressure from the developers.
I can only imagine people complaining 'well #C allows/did it'. This path leads to what happened with C++.

IIRC even Bloch wrote that he thinks Generics was a bad idea. (from the book 'Coders at work' IIRC)

Language Specification should not be a popularity contest.
I also do not like certain stuff, but I accept the design and actually am happy that the Java language is still very clean.

And yes, it is often more code. And?
Also it should be noted that you can make any kind of code ugly and hacked or clean and beautiful.
Offline zingbat

Senior Member




Java games rock!


« Reply #38 - Posted 2009-11-20 21:38:02 »

I wander when someone is going to ask for first class object continuations in Java.

http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-15.html#node_chap_13
Offline pjt33
« Reply #39 - Posted 2009-11-20 22:15:27 »

What's clean and minimal about that?  Just make functions first class types and they can fit consistently with the rest of the syntax.  I admit that the # and use of annotation do smell a bit fishy.

The thing is, it seems simplicity in one dimension frequently entails complexity in another; make an operating appear system simple to use, you often need to introduce more sophisticated technology to facilitate it.

To make a programming language able to express certain things neatly at a high level, it can serve to complicate the language.  Of course great care needs to be taken to prevent this from backfiring... but I don't think avoiding closures is an example where they're better off being left out.
I've been influenced by functional programming when writing Java for almost a decade now, and I still try to do the occasional Project Euler problem with SML to keep my hand in, so I'm not anti-FP, anti-first-class-functions, etc. However, adding them to Java now is bound to be kludgy. Deciding what should be a first class type is something which should be done when you start designing a language, not after distributing millions of copies with which you need to be backwards-compatible.

To me it makes more sense to negotiate to bring Scala or Clojure in-house and take a .NET-style approach of officially supporting multiple languages which compile to the same bytecode and can easily interact with each other than to try to make one language serve as the jack of all trades.
Games published by our own members! Check 'em out!
Legends of Yore - The Casual Retro Roguelike
Offline i30817

Junior Member





« Reply #40 - Posted 2009-11-20 22:55:27 »

I wander when someone is going to ask for first class object continuations in Java.

http://www.ccs.neu.edu/home/dorai/t-y-scheme/t-y-scheme-Z-H-15.html#node_chap_13


Funny you should say that:

http://www.java.net/blogs/forax/

At least the experimental jvm has them right now.

 Cheesy
Offline i30817

Junior Member





« Reply #41 - Posted 2009-11-20 22:57:18 »

Actually that is very cool if kept behind as syntactic sugar.

You know you want for each generators.
Offline OverKill

Junior Member




Java games rock!


« Reply #42 - Posted 2009-11-21 20:05:34 »

Funny you should say that:

http://www.java.net/blogs/forax/

At least the experimental jvm has them right now.

 Cheesy
And that blog entry proves my point:
Quote
I have always wanted to have generator  in Java. After all, Python have this feature, Ruby and C#(*) too.

@Continuations:
First thing I though when I read a summary was ... 'is a GOTO by any other name not just as evil?'.

Pls, stop turning this into C++/C#!
Offline xinaesthetic

Senior Member


Medals: 1



« Reply #43 - Posted 2009-11-21 21:09:01 »

Pls, stop turning this into C++/C#!
There's nowt wrong with C#, lad.  Well, maybe not completely nowt, but it's not C++.
Offline zingbat

Senior Member




Java games rock!


« Reply #44 - Posted 2009-11-21 21:38:50 »

In case someone missed the point i was being ironic. I prefer Java to stay within the mutli-threading/imperative programming paradigm.

The biggest stinker in Java is by far generics. I would rather see this fixed to be more intuitive and less restrictive.

And also remove primitives. Everything should be an Object. A good compiler can optimize simple immutable objects to be as fast as primitive objects.
Offline Roquen
« Reply #45 - Posted 2009-11-22 09:46:19 »


Godel's Incompleteness Theorem expresses the fact that algebraic systems can reach a point of complexity where there are things that are true in the system that cannot be expressed in the system and there are things that can be expressed in the system that are not true.  It is impossible to have a system where all valid strings are true and all truths are valid strings.

I meant this as an analogy, not literally.  Looking at it from a constructive manner (as you stated), Computer languages are formal systems and as they are made more complex, serious design issues are possible, such as undecidabity and ambiguous grammars.

That has NOTHING to do with making a language that "fit's all needs" as you claim.  That is a matter of taste whereas Godel is referring to a property of systems, namely the truthfulness of valid strings in the system.

WRT: "Operator overloading". I explictly stated that "my issue" is with the argument that it leads to bad programming practices.  It is impossible for a language design to prevent bad programming. There are reasonable arguments against polymorphic methods (of which operator overloading is simply sugar), but I don't think this is one of them. If you have a language with method polymorphism, I like operator overloading because a fair amount of my work is mathematical in nature and it's a nightmare to read/write without. (As an aside, was anyone played around with Fortress?)  When the number of operations is small, it doesn't really matter, when large..it's a really issue.

And also remove primitives. Everything should be an Object. A good compiler can optimize simple immutable objects to be as fast as primitive objects.

Assuming this wasn't a joke: There are plenty of purely OO (or prototype based) languages available if this is truly what you want.  The compilers in current VMs are not great at basic optimizations and transform objects into primatives would not be easy.  This is because of the dynamic loading/compiling/linking nature of Java.  It would require a good lifetime compiler framework to make feasiable.  This suggestion would be an entirely new language...besides Java doesn't have operator overloading.  Wink
Offline princec

JGO Kernel


Medals: 391
Projects: 3
Exp: 16 years


Eh? Who? What? ... Me?


« Reply #46 - Posted 2009-11-22 11:48:49 »

I wouldn't want primitives to become Objects. That's why they're primitives! They're the tacit admission that somewhere underneath the JVM is a real machine that only understands primitives, and some of us like to be assured that they'll behave in nice predictable primitive-like ways. The point about Objects is that they're pointers to other data, and primitives aren't.

Which sort of leaves us wanting lightweight objects in the language doesn't it (ie structs). (Not MappedObjects)

Cas Smiley

Offline zingbat

Senior Member




Java games rock!


« Reply #47 - Posted 2009-11-22 14:07:03 »

You already have direct buffers. Why would you need yet another primitive data type and how would this work with generics? Just look at what happens when mixing primitive arrays with generics already.

" The compilers in current VMs are not great at basic optimizations and transform objects into primatives would not be easy. This is because of the dynamic loading/compiling/linking nature of Java.  It would require a good lifetime compiler framework to make feasiable. "

Every VM uses primitive data types but these are usually hidden away in VM code and not accessed directly like you do in Java. It's the compiler and not the VM that does this kind of optimization and decides when it's safe to convert an object reference to a VM internal data type, but this would only be visible if you looked inside the generated VM code.
Offline DzzD
« Reply #48 - Posted 2009-11-22 14:29:32 »

arrrg, you'r crazy ! dont do that

Quote
WRT: "Operator overloading". I explictly stated that "my issue" is with the argument that it leads to bad programming practices.  It is impossible for a language design to prevent bad programming. There are reasonable arguments against polymorphic methods (of which operator overloading is simply sugar), but I don't think this is one of them. If you have a language with method polymorphism, I like operator overloading because a fair amount of my work is mathematical in nature and it's a nightmare to read/write without. (As an aside, was anyone played around with Fortress?)  When the number of operations is small, it doesn't really matter, when large..it's a really issue.
operator overloading is nice sometime but I think that it maybe confusing in many many case.

I find pretty nice to use somthing like the following that let me write easy undertadable code :

1  
2  
3  
4  
5  
6  
7  
8  
9  
10  
11  
12  
13  
14  
public Vector add(Vector v)
{
 x+=v.x etc...
 retur this;
}

public Vector mul(double m)
{
 x*=m etc...
 retur this;
}

//then you can write things like below wich I found are less confusing, and with one you are not limited by the number of operators :
v.add(v2).mul(v3).div(2).normalize()


you simply have to read from left to right (no operator priority problem)

Offline princec

JGO Kernel


Medals: 391
Projects: 3
Exp: 16 years


Eh? Who? What? ... Me?


« Reply #49 - Posted 2009-11-22 16:12:56 »

"Structs" are just Nice Ways of accessing clusters of primitive data types. Look at the complete joke that is Java's tuple/matrix handling ability, or complex numbers. At least one of those things is something that games programmers could really, really do with in Java because current handling is the opposite of "elegant" and "simple" and "intuitive".

As for how it works with generics - well, it wouldn't, just like primitives don't. But I think generics get abused a little too much anyway. They work fine, they're not too complicated if you don't try to over use them, and the new Java 7 syntax for inferring generic type sigs should make them far less verbose.

Quote
1  
v.add(v2).mul(v3).div(2).normalize();
is just hideous. How about
1  
2  
3  
4  
5  
6  
7  
8  
public operator Vector add(Vector left, Vector right) {
    return new Vector(left.x + right.x, left.y + right.y, left.z + right.z);
}
public operator Vector mul(Vector left, Vector right) {
    return new Vector(left.x + right.x, left.y + right.y, left.z + right.z);
}
etc.
(v add v2 mul v3 div 2).normalize();

where operator is a new keyword which defines a static method that can take 0, 1, or 2 arguments? You'd them import static Vector.add; as normal.

Cas Smiley

Offline DzzD
« Reply #50 - Posted 2009-11-22 16:24:30 »

"Structs" are just Nice Ways of accessing clusters of primitive data types. Look at the complete joke that is Java's tuple/matrix handling ability, or complex numbers. At least one of those things is something that games programmers could really, really do with in Java because current handling is the opposite of "elegant" and "simple" and "intuitive".

As for how it works with generics - well, it wouldn't, just like primitives don't. But I think generics get abused a little too much anyway. They work fine, they're not too complicated if you don't try to over use them, and the new Java 7 syntax for inferring generic type sigs should make them far less verbose.
is just hideous. How about
1  
2  
3  
4  
5  
6  
7  
8  
public operator Vector add(Vector left, Vector right) {
    return new Vector(left.x + right.x, left.y + right.y, left.z + right.z);
}
public operator Vector mul(Vector left, Vector right) {
    return new Vector(left.x + right.x, left.y + right.y, left.z + right.z);
}
etc.
(v add v2 mul v3 div 2).normalize();

where operator is a new keyword which defines a static method that can take 0, 1, or 2 arguments? You'd them import static Vector.add; as normal.

Cas Smiley

and in the samle above you make 4 new, say welcom to the garbage....

Offline Spasi
« Reply #51 - Posted 2009-11-22 17:17:40 »

and in the samle above you make 4 new, say welcom to the garbage....
That's not the point. Besides, 7's escape analysis should be able to optimize away object allocations in that example.

My 2c on operator overloading; I personally never code outside an intelligent IDE and I'm assuming most of you don't either. For me, modern programming and the size of applications being developed the past decade would not be possible without these IDEs doing the kind of code analysis they do. Code isn't simple text anymore. C++ didn't have intelligent IDEs 20 years ago when operator overloading made people lose their hair. Java on the other hand is being powered by these tools, it's part of its success. A scary "+" in a .java text file is not so scary and mysterious and error prone in an IDE that has done its analysis and understands what it is. I don't know, in this context, the arguments against operator overloading sound exaggerated to me.
Offline JL235

JGO Coder


Medals: 10



« Reply #52 - Posted 2009-11-22 18:40:58 »

Every VM uses primitive data types but these are usually hidden away in VM code and not accessed directly like you do in Java. It's the compiler and not the VM that does this kind of optimization and decides when it's safe to convert an object reference to a VM internal data type, but this would only be visible if you looked inside the generated VM code.
The Sun compiler makes no optimizations at all. It leaves them for the JVM to perform at startup and runtime. This allows the optimizations to specifically target the platform it's running on. I believe the IBM compiler does optimize code, but it's only small minor stuff.

Offline DzzD
« Reply #53 - Posted 2009-11-22 19:08:04 »

That's not the point. Besides, 7's escape analysis should be able to optimize away object allocations in that example.
no it wont because it would result in an "incorrect" code, you call a method and intend it to allocate a new object that will make you initial object not modified, this kind of optimisations cannot be made by escape analysis and even futur one because optimized & unoptimized code should give the exact same result and reaction for any possible case.

you can turn it in any sense but knowing a little what the language do behind will always be necessary, Java is not slow for sure but lot of programs made in Java are (eclipse is one exemple from many others EDIT : or a better exemple : JavaStore wich requiere high end PC to display two Icons... pfff...  what a shame...)  because lot of Java programmer have ( are formed with ) this view point wich is : I dont have to bother in optimizing my code this is just a stupid old scholl way, and this is just IMO a wrong way, what make the strenght of C/C++ vs Java is just programmer approach because in C you are forced to take care of how your code will be understand by the computer. I did tones of web business application in Java and it is fine to use heavy IDE/Framework for such program because nobody care if they are  just damnly slow and if requiered then you just add a new server... but for desktop application having this approach just result in making people think : Java == slow.

Offline DzzD
« Reply #54 - Posted 2009-11-22 19:21:21 »

for example think about adding String : wich is one overloaded operator in Java

in a critical realtime application, most people dont know that there is an allocation inside s=s1+s2 and you can encouter this kind of problem where people was just lost because of the slowness of their program, changing two line resulting in 100% speed gain when this kind of operation are in a time critical section of the code.

and most people aware of this issue / slowness will just NOT use s=s1+s2 but implements their own or use other String manipulation object

Offline Spasi
« Reply #55 - Posted 2009-11-22 20:05:00 »

no it wont because it would result in an "incorrect" code, you call a method and intend it to allocate a new object that will make you initial object not modified, this kind of optimisations cannot be made by escape analysis and even futur one because optimized & unoptimized code should give the exact same result and reaction for any possible case.
Well, you're wrong. Even if we assume that the result of (v add v2 mul v3 div 2).normalize() escapes the current context, with escape analysis only one object would be allocated, instead of 3 or 4. Again, this is beyond the point of whether operator overloading is good or evil. You could write add/mul/div/normalize so that no objects are allocated. Smiley

As for string manipulation. First of all, Java compiles string concatenation to StringBuilder (StringBuffer on older versions) allocation, x number of appends, followed by toString(). So, of course you'd use something other than "foo" + "bar". But why not use operator overloading for StringBuilder's append (or whatever custom class/method you're going to use)? Tongue
Offline DzzD
« Reply #56 - Posted 2009-11-22 20:30:29 »

Well, you're wrong. Even if we assume that the result of (v add v2 mul v3 div 2).normalize() escapes the current context, with escape analysis only one object would be allocated, instead of 3 or 4. Again, this is beyond the point of whether operator overloading is good or evil. You could write add/mul/div/normalize so that no objects are allocated. Smiley
so let's try it and compare !

I like how you are faithful  Tongue
but... anyway let say that god exist and it create the world with some kind of magic stick... (pff something get into me and write the previous sentence, this is not me argg get out !) : abstracting again and again (as adding libraries in the core) will just make java fall into something that I would call "the VisualBasic syndrom", my point is that there is a limit of complexity/abstraction/help that make people dont use libraries/language features or IDE features or use it very bad in different area : JavaFX / Spring / Hybernate / Eclipse / WebSphere / hundreds of others => all offer thousand of useless features, are hard/impossible to fully use, are memory killer & damnly slow, operator overloading is just similar but in a different computer area (language), Java Generics is one in the language area.

Offline zingbat

Senior Member




Java games rock!


« Reply #57 - Posted 2009-11-22 21:13:29 »

The Sun compiler makes no optimizations at all. It leaves them for the JVM to perform at startup and runtime. This allows the optimizations to specifically target the platform it's running on. I believe the IBM compiler does optimize code, but it's only small minor stuff.

That's OK for translating byte codes to native code but in this case you are optimizing at an higher level, deciding in what context an immutable object like Integer can be safely replaced by an equivalent primitive data type. This is an obvious optimization in many cases and the compiler should do this automatically.
Offline Riven
« League of Dukes »

JGO Overlord


Medals: 803
Projects: 4
Exp: 16 years


Hand over your head.


« Reply #58 - Posted 2009-11-22 22:04:58 »

Well, you're wrong. Even if we assume that the result of (v add v2 mul v3 div 2).normalize() escapes the current context, with escape analysis only one object would be allocated, instead of 3 or 4.

Well, you're wrong. The JIT seems to know how to inline methods pretty well, so once it inlined everything into everything, there is a fair chance that even that 'last' object does not escape the 'new' current context.

Hi, appreciate more people! Σ ♥ = ¾
Learn how to award medals... and work your way up the social rankings
Offline princec

JGO Kernel


Medals: 391
Projects: 3
Exp: 16 years


Eh? Who? What? ... Me?


« Reply #59 - Posted 2009-11-22 22:20:20 »

DzzD: yes, you are in fact wrong. EA completely removes object allocations like this, except where they are actually required for code correctness, leaving you free to write clean and simple looking code and let the machine do the hard bit of figuring out how to implement it fastest. Which is what Java has been doing all along for us on many other fronts.

It has to be said though that EA is not actually here yet, except in Excelsior JET. BTW has anyone here tried it recently? I used it back in v3.5 days or so and it was utterly, blindingly fast compared to the Sun JREs of the day (2003 or so, 1.4.2)

Cas Smiley

Pages: 1 [2] 3 4 ... 6
  ignore  |  Print  
 
 
You cannot reply to this message, because it is very, very old.

 

Add your game by posting it in the WIP section,
or publish it in Showcase.

The first screenshot will be displayed as a thumbnail.

Pippogeek (40 views)
2014-09-24 16:13:29

Pippogeek (31 views)
2014-09-24 16:12:22

Pippogeek (21 views)
2014-09-24 16:12:06

Grunnt (47 views)
2014-09-23 14:38:19

radar3301 (29 views)
2014-09-21 23:33:17

BurntPizza (65 views)
2014-09-21 02:42:18

BurntPizza (37 views)
2014-09-21 01:30:30

moogie (44 views)
2014-09-21 00:26:15

UprightPath (53 views)
2014-09-20 20:14:06

BurntPizza (55 views)
2014-09-19 03:14:18
List of Learning Resources
by Longor1996
2014-08-16 10:40:00

List of Learning Resources
by SilverTiger
2014-08-05 19:33:27

Resources for WIP games
by CogWheelz
2014-08-01 16:20:17

Resources for WIP games
by CogWheelz
2014-08-01 16:19:50

List of Learning Resources
by SilverTiger
2014-07-31 16:29:50

List of Learning Resources
by SilverTiger
2014-07-31 16:26:06

List of Learning Resources
by SilverTiger
2014-07-31 11:54:12

HotSpot Options
by dleskov
2014-07-08 01:59:08
java-gaming.org is not responsible for the content posted by its members, including references to external websites, and other references that may or may not have a relation with our primarily gaming and game production oriented community. inquiries and complaints can be sent via email to the info‑account of the company managing the website of java‑gaming.org
Powered by MySQL Powered by PHP Powered by SMF 1.1.18 | SMF © 2013, Simple Machines | Managed by Enhanced Four Valid XHTML 1.0! Valid CSS!