execution

I'm reading Javascript Web Applications, from O'Reilly. At various points in the book, the author uses something along the following: instance.init.apply(instance, arguments); Does this make any sense? Isn't this exactly the same as: instance.init(arguments); .call() and .apply() are used to manually set the execution context of a function. Why should I use them when I'm intending to use the original execution context anyway? The point is that arguments is an array-like object. Doing ... instance.init(arguments); ... passes one argument, which is an array-like object containing certain

This is a little difficult to explain, but i'll try my best. This is similar to the code i'm currently running. function func1() { func2() } function func2() { exit(); } I need to be able to stop the execution of func1 from within func2, but I need a better way to do it than exit(). Since the caller of func1 might have other operations to do, I don't want to stop them as well, I just want to stop the rest of func1 from executing. I'm aware that I could put a simple if statement in func1 to detect the return value of func2 and then return if it's a certain value, but that's a bit messy too. So

My main process calls an external library method. This method sometimes hangs. I can not fix the external library because another company is responsible for it. I want to use a Thread for the library calls with a defined execution timer. When the method call takes to long, the Thread with the Runnable in which the method call is placed should stop and the main process should go forward. Main Thread wait Execute Thread start Start timer Thread When timer thread is finished kill Execute Thread Execute Thread stop Main thread resume Does anybody have some code this logic is for, a design pattern

I did some reading up on JLS 15.7.4 and 15.12.4.2 , but it doesn't guarantee that there won't be any compiler/runtime optimization that would change the order in which method arguments are evaluated. Assume the following code: public static void main (String[] args) { MyObject obj = new MyObject(); methodRelyingOnEvalOrder(obj, obj.myMethod()); } public static Object methodRelyingOnEvalOrder(MyObject obj, Object input) { if (obj.myBoolean()) return null; else return input; } Is it guaranteed that the compiler or runtime will not do a false optimization such as the following? This optimization

I'm not really sure what causes this so please forgive me if I couldn't find the information I needed in a search. Here is an example: Let's say that we have a folder with 1,000,000 files. Running Directory.GetFiles() on that will take a few minutes. However, running it again right after will take only a few seconds. Why does this happen? Are the objects being cached somewhere? How can I run it with the original time? Hard drives have internal caches that will help speed up subsequent reads. Try reading a bunch of other directory information in a completely different sector to clear the cache.

I am preparing myself for Java certification test and I have found an interesting question related to the execution of Java static blocks. I have spent a lot of time reading about this topic, but I didn't find the answer I was looking for. I know that static blocks are executed when the class is loaded into JVM or when the main method is invoked, but... package oneClassTasks; class Parent { static int age; } class Child extends Parent { static { age = 5; System.out.println("child's static block"); } } public class XXX { public static void main(String args[]) { System.out.println("Child age is