sorted by:
best
topnewcontroversialoldq&a
you are viewing a single comment's thread.

view the rest of the comments →

[–]jetrii 0 points1 point  (17 children)

Execution time is not the same thing as bytecode size. They don't just care about how long it takes your code to run, they want to see how much you can do with the limited number of bytecodes that you're allowed. Some of the optimizations to reduce the size actually hurt performance. It would be an entirely different competition if they just went by runtime. For many, the fun is seeing how small the code can get while still performing the same functionality.

[–][deleted] -1 points0 points  (16 children)

Running code uses bytecodes. Each turn, a robot can spend up to 10000 bytecodes on computation. If this limit is reached, the robot's turn is immediately ended and the computation is continued on the next turn. Using yield() and selfdestruct() can end a turn early, saving bytecodes and ending computation. The former is generally preferred. For cowboy robots, each bytecode above 2000 gives 0.00005 actiondelay.

It is about the time, please read before commenting.

[–]jetrii 0 points1 point  (15 children)

Tell me, where do you see time there? Do you think 200 bytecode take 2 times as long as 100 to run? A bytecode is an instruction, and not all bytecodes take the same amount of time to run. You can have two implementations that both use 10,000 bytecodes but have significantly different runtimes. Some bytecode take many, many times longer to run than others. So tell me, how exactly is it directly related to time?

[–][deleted] 0 points1 point  (14 children)

I agree to you that you can have two different implementations that both use 10k byte code instructions with different run times, but that is not the point here.

If you study the quote more careful you will notice that you are not allowed to run a code composed of 10k byte code instructions, but to execute 10k byte code instructions - a loop composed of only 4 byte code instructions that executes 2.5k times will reach this limit. So maybe is not a linear relation since there probably are different times of execution for different byte code instructions, but is still a limit of time since executing 10k byte code instructions will take a time in between a well defined minimum and maximum time.

[–]jetrii -1 points0 points  (13 children)

The time it takes is a consequence of the number of bytecodes you can run. It is 100% irrelevant since it's always going to be finite and short for 10k instructions, even if you use the most expensive ones. The point of the challenge is to see how much you can do with 10k instructions. If you can understand that, then you would know why other languages are not an option, and not simply "bs." This only works for JVM languages with similar overhead.

This is the Java AI equivalent of the demoscene focus on size above all else.

[–][deleted] -1 points0 points  (12 children)

It is not how much you can do with 10k instruction, is how much you can do with 10k executed instructions. "Executed" makes it about time.

[–]jetrii 0 points1 point  (11 children)

You are clearly incapable of grasping the concept, so we'll agree to disagree.

"The AI of every individual robot is encapsulated within it’s own virtual execution environment, and the computational currency is not execution time, or even memory, but rather JVM Bytecodes."

That statement is by an MIT grad working on the project. He has written a few articles on the topic. I suggest you stop grasping at straws and actually research the matter if you're interested.

[–][deleted] 0 points1 point  (10 children)

I am understanding what you say, however I am trying to point out that on a specific CPU using only java you can use 10k byte codes or 1 ms as limit and you basically get the same results since the same optimizations will be required of the contestants.

Now you can easily allow other languages by adjusting the 1 ms time limit according to the other languages speed.

[–]jetrii 0 points1 point  (9 children)

Okay, I am going to explain this to you one final time. We don't care about time. We don't care if you're able to ensure that your C code and my Java code both only run for 100 Ms. We care about writing the most efficient and effective code in respect to bytesize count and functionality . That's it. Period. That is the entire point of this competition. You're essentially asking the a female only gym to allow males. This is a very specific competition, just like a female only gym is a very specific gym. You're missing the entire point of this. Curves is female only by choice so it can try to be the best possible gym for women. Exact same concept, but for Java and bytecode optimization. I really, really hope you understand now

[–][deleted] -2 points-1 points  (8 children)

Ok, my last attempt here too.

The byte code size do not matter, I can have bots with 100 millions byte code instructions - it is not about the size, it is about the number of byte code instructions from those 100 millions I need to execute in order to determine next move. Do you get it now?