Mike Pall has talked about this in a few places: 

* http://article.gmane.org/gmane.comp.lang.lua.general/58908
* http://lambda-the-ultimate.org/node/3851
* http://www.reddit.com/user/mikemike

As with every performant system, the answer in the end comes down to two things: algorithms and engineering. LuaJIT uses advanced compilation techniques, and it also has a very finely engineered implementation. For example, when the fancy compilation techniques can&#39;t handle a piece of code, LuaJIT falls back to an very fast interpreter written in x86 assembly.

LuaJIT gets double points on the engineering aspect, because not only is LuaJIT itself well-engineered, but the Lua language itself has a simpler and more coherent design than Python and JavaScript. This makes it (marginally) easier for an implementation to provide consistently good performance.


I can&#39;t understand why the answer to this isn&#39;t in the Android developer docs; I find them consistently frustrating.

Re the openFileOutput() method on the Context class to open a file for writing, what internal storage file path does it write to?

http://developer.android.com/reference/android/content/Context.html

http://developer.android.com/guide/topics/data/data-storage.html#filesInternal



What file system path is used by Android&#39;s Context.openFileOutput()?

I have two instances of my app: one for development, one for production. My development database is called `snip_development` and my production database is called `snip`.

I&#39;ve been doing migrations all along in my development environment and it&#39;s been going just fine. I recently created a production instance of my app but `rake db:migrate` doesn&#39;t seem to have any effect. After I run `rake db:migrate` and log into my database server, I can see that `snip_development` has all the tables I expect it to but `snip` doesn&#39;t have any tables at all.

I suspect the problem is that `rake db:migrate` is running on `snip_development` instead of `snip` and that&#39;s why I&#39;m not seeing anything happen.

How do I get my migrations to work on my production database?

rake db:migrate doesn&#39;t seem to work in production

EDIT: unfortunately LuaJIT was taken out of the comparison in the link below.

This &lt;a href=&quot;http://shootout.alioth.debian.org/u64/which-programming-languages-are-fastest.php&quot;&gt;comparison&lt;/a&gt; of programming languages shows that LuaJIT has an over tenfold improvement over the normal Lua implementation.
Why is the change so big? Is there something specific about Lua that makes it benefit a lot from JIT compilation?
Python is dynamically typed and compiled to bytecode as well, so why doesn&#39;t PyPy (that has JIT now, I believe) show such a large jump in performance?

Why is LuaJIT so good?

<p>EDIT: unfortunately LuaJIT was taken out of the comparison in the link below.</p>
<p>This <a href="<a href=" http:="" shootout.alioth.debian.org="" u64="" which-programming-languages-are-fastest.php&#x26;quot;&#x26;gt;comparison&#x26;lt;="" a&#x22;="">http://shootout.alioth.debian.org/u64/which-programming-languages-are-fastest.php">comparison&#x3C;/a</a>> of programming languages shows that LuaJIT has an over tenfold improvement over the normal Lua implementation.
Why is the change so big? Is there something specific about Lua that makes it benefit a lot from JIT compilation?
Python is dynamically typed and compiled to bytecode as well, so why doesn't PyPy (that has JIT now, I believe) show such a large jump in performance?</p>


How can I check if a file exists using Lua?

Check if a file exists with Lua

I know [Love2D][1] and [Corona SDK][2] (for mobile devices). Is there any other game engines that use Lua you recommend?


  [1]: http://love2d.org/ &quot;Love2D&quot;
  [2]: https://coronalabs.com/

What is a good game engine that uses Lua?

Is there anyway to use inline conditions in Lua?

Such as:

    print(&quot;blah: &quot; .. (a == true ? &quot;blah&quot; : &quot;nahblah&quot;))

Inline conditions in Lua (a == b ? &quot;yes&quot; : &quot;no&quot;)?

My directory structure looks like this:

    |-- ball.lua
    |-- entity.lua
    |-- test
        `-- ball_test.lua

I&#39;m using the following code in test/ball_test.lua to require ball.lua from the parent directory:

    package.path = package.path .. &quot;;../entity.lua&quot;
    require(&quot;entity&quot;)
    package.path = package.path .. &quot;;../ball.lua&quot;
    require(&quot;ball&quot;)

entity.lua is a dependency of ball.lua. So I require(&quot;entity&quot;) first otherwise I get a module &#39;entity.lua&#39; not found error. This seems like a hack, what&#39;s a better way to do this?


Is there a better way to require file from relative path in lua

In the Lua wiki I found a way to define default values for missing arguments:

	function myfunction(a,b,c)
		b = b or 7
		c = c or 5
		print (a,b,c)
	end

Is that the only way? The PHP style `myfunction (a,b=7,c=5)` does not seem to work. Not that the Lua way doesn&#39;t work, I am just wondering if this is the only way to do it.

Define default values for function arguments

I&#39;ve become a bit confused about the details of how the JIT compiler works. I know that C# compiles down to IL. The first time it is run it is JIT&#39;d. Does this involve it getting translated into native code? Is the .NET runtime (as a Virtual Machine?) interact with the JIT&#39;d code? I know this is naive, but I&#39;ve really confused myself. My impression has always been that the assemblies are not interpreted by the .NET Runtime but I don&#39;t understand the details of the interaction. 

C# JIT compiling and .NET

If I am using a constant that is **needed only in a method**, is it best to declare the const within the method scope, or in the class scope? Is there better performance declaring it in the method? If that is true, I think it&#39;s more standard to define them at class scope (top of file) to change the value and recompile easier.

    public class Bob
    {
       private const int SomeConst = 100; // declare it here?
       public void MyMethod()
       {
          const int SomeConst = 100; // or declare it here?
          // Do something with SomeConst
       }
    }

Defining Local Variable const vs Class const

Many dynamic languages implement (or want to implement) a JIT Compiler in order to speed up their execution times. Inevitably, someone from the peanut gallery asks why they don&#39;t use LLVM. The answer is often, &quot;LLVM is unsuitable for building a JIT.&quot; (For Example, Armin Rigo&#39;s comment [here.][1])

**Why is LLVM Unsuitable for building a JIT?**

Note: I know LLVM has its own JIT. If LLVM used to be unsuitable, but now is suitable, please say what changed. I&#39;m not talking about running LLVM Bytecode on the LLVM JIT, I&#39;m talking about using the LLVM libraries to implement a JIT for a dynamic language.


  [1]: http://morepypy.blogspot.com/2008/04/float-operations-for-jit.html?showComment=1208773800000#c6322995253226647458

Why is llvm considered unsuitable for implementing a JIT?

**Intro:**  I write high-performance code in C#.  Yes, I know C++ would give me better optimization, but I still choose to use C#.  I do not wish to debate that choice.  Rather, I&#39;d like to hear from those who, like me, are trying to write high-performance code on the .NET Framework.

**Questions:**

 - Why is the operator in the code below slower than the equivalent
   method call??
 - Why is the method passing two doubles in the code below
   faster than the equivalent method passing a struct that has two
   doubles inside? (A: older JITs optimize structs poorly)
 - Is there a way to get the .NET JIT Compiler to treat
   simple structs as efficiently as the members of the struct? (A: get newer JIT)

**What I think I know:**
The original .NET JIT Compiler would not inline anything that involved a struct.  Bizarre given structs should only be used where you need small value types that should be optimized like built-ins, but true.  Fortunately, in .NET 3.5SP1 and .NET 2.0SP2, they made some improvements to the JIT Optimizer, including improvements to inlining, particularly for structs.  (I am guessing they did that because otherwise the new Complex struct that they were introducing would have performed horribly... so the Complex team was probably pounding on the JIT Optimizer team.)  So, any documentation prior to .NET 3.5 SP1 is probably not too relevant to this issue.

**What my testing shows:**
I have verified that I do have the newer JIT Optimizer by checking that C:\Windows\Microsoft.NET\Framework\v2.0.50727\mscorwks.dll file does have version &gt;= 3053 and so should have those improvements to the JIT optimizer.  However, even with that, what my timings and looks at the disassembly both show are:

The JIT-produced code for passing a struct with two doubles is far less efficient than code that directly passes the two doubles.

The JIT-produced code for a struct method passes in &#39;this&#39; far more efficiently than if you passed a struct as an argument.

The JIT still inlines better if you pass two doubles rather than passing a struct with two doubles, even with the multiplier due to being clearly in a loop.

**The Timings:**
Actually, looking at the disassembly I realize that most of the time in the loops is just accessing the test data out of the List&lt;Element&gt;.  The difference between the four ways of making the same calls is dramatically different if you factor out the overhead code of the loop and the accessing of the data.  I get anywhere from 5x to 20x speedups for doing PlusEqual(double, double) instead of PlusEqual(Element).  And 10x to 40x for doing PlusEqual(double, double) instead of operator +=.  Wow.  Sad.

Here&#39;s one set of timings:

    Populating List&lt;Element&gt; took 320ms.
    The PlusEqual() method took 105ms.
    The &#39;same&#39; += operator took 131ms.
    The &#39;same&#39; -= operator took 139ms.
    The PlusEqual(double, double) method took 68ms.
    The do nothing loop took 66ms.
    The ratio of operator with constructor to method is 124%.
    The ratio of operator without constructor to method is 132%.
    The ratio of PlusEqual(double,double) to PlusEqual(Element) is 64%.
    If we remove the overhead time for the loop accessing the elements from the List...
    The ratio of operator with constructor to method is 166%.
    The ratio of operator without constructor to method is 187%.
    The ratio of PlusEqual(double,double) to PlusEqual(Element) is 5%.

**The Code:**

    namespace OperatorVsMethod
    {
      public struct Element
      {
        public double Left;
        public double Right;
    
        public Element(double left, double right)
        {
          this.Left = left;
          this.Right = right;
        }
    
        public static Element operator +(Element x, Element y)
        {
          return new Element(x.Left + y.Left, x.Right + y.Right);
        }
    
        public static Element operator -(Element x, Element y)
        {
          x.Left += y.Left;
          x.Right += y.Right;
          return x;
        }    
    
        /// &lt;summary&gt;
        /// Like the += operator; but faster.
        /// &lt;/summary&gt;
        public void PlusEqual(Element that)
        {
          this.Left += that.Left;
          this.Right += that.Right;
        }    
    
        /// &lt;summary&gt;
        /// Like the += operator; but faster.
        /// &lt;/summary&gt;
        public void PlusEqual(double thatLeft, double thatRight)
        {
          this.Left += thatLeft;
          this.Right += thatRight;
        }    
      }    
      
      [TestClass]
      public class UnitTest1
      {
        [TestMethod]
        public void TestMethod1()
        {
          Stopwatch stopwatch = new Stopwatch();
    
          // Populate a List of Elements to multiply together
          int seedSize = 4;
          List&lt;double&gt; doubles = new List&lt;double&gt;(seedSize);
          doubles.Add(2.5d);
          doubles.Add(100000d);
          doubles.Add(-0.5d);
          doubles.Add(-100002d);
    
          int size = 2500000 * seedSize;
          List&lt;Element&gt; elts = new List&lt;Element&gt;(size);
    
          stopwatch.Reset();
          stopwatch.Start();
          for (int ii = 0; ii &lt; size; ++ii)
          {
            int di = ii % seedSize;
            double d = doubles[di];
            elts.Add(new Element(d, d));
          }
          stopwatch.Stop();
          long populateMS = stopwatch.ElapsedMilliseconds;
    
          // Measure speed of += operator (calls ctor)
          Element operatorCtorResult = new Element(1d, 1d);
          stopwatch.Reset();
          stopwatch.Start();
          for (int ii = 0; ii &lt; size; ++ii)
          {
            operatorCtorResult += elts[ii];
          }
          stopwatch.Stop();
          long operatorCtorMS = stopwatch.ElapsedMilliseconds;
    
          // Measure speed of -= operator (+= without ctor)
          Element operatorNoCtorResult = new Element(1d, 1d);
          stopwatch.Reset();
          stopwatch.Start();
          for (int ii = 0; ii &lt; size; ++ii)
          {
            operatorNoCtorResult -= elts[ii];
          }
          stopwatch.Stop();
          long operatorNoCtorMS = stopwatch.ElapsedMilliseconds;
    
          // Measure speed of PlusEqual(Element) method
          Element plusEqualResult = new Element(1d, 1d);
          stopwatch.Reset();
          stopwatch.Start();
          for (int ii = 0; ii &lt; size; ++ii)
          {
            plusEqualResult.PlusEqual(elts[ii]);
          }
          stopwatch.Stop();
          long plusEqualMS = stopwatch.ElapsedMilliseconds;
    
          // Measure speed of PlusEqual(double, double) method
          Element plusEqualDDResult = new Element(1d, 1d);
          stopwatch.Reset();
          stopwatch.Start();
          for (int ii = 0; ii &lt; size; ++ii)
          {
            Element elt = elts[ii];
            plusEqualDDResult.PlusEqual(elt.Left, elt.Right);
          }
          stopwatch.Stop();
          long plusEqualDDMS = stopwatch.ElapsedMilliseconds;
    
          // Measure speed of doing nothing but accessing the Element
          Element doNothingResult = new Element(1d, 1d);
          stopwatch.Reset();
          stopwatch.Start();
          for (int ii = 0; ii &lt; size; ++ii)
          {
            Element elt = elts[ii];
            double left = elt.Left;
            double right = elt.Right;
          }
          stopwatch.Stop();
          long doNothingMS = stopwatch.ElapsedMilliseconds;
    
          // Report results
          Assert.AreEqual(1d, operatorCtorResult.Left, &quot;The operator += did not compute the right result!&quot;);
          Assert.AreEqual(1d, operatorNoCtorResult.Left, &quot;The operator += did not compute the right result!&quot;);
          Assert.AreEqual(1d, plusEqualResult.Left, &quot;The operator += did not compute the right result!&quot;);
          Assert.AreEqual(1d, plusEqualDDResult.Left, &quot;The operator += did not compute the right result!&quot;);
          Assert.AreEqual(1d, doNothingResult.Left, &quot;The operator += did not compute the right result!&quot;);
    
          // Report speeds
          Console.WriteLine(&quot;Populating List&lt;Element&gt; took {0}ms.&quot;, populateMS);
          Console.WriteLine(&quot;The PlusEqual() method took {0}ms.&quot;, plusEqualMS);
          Console.WriteLine(&quot;The &#39;same&#39; += operator took {0}ms.&quot;, operatorCtorMS);
          Console.WriteLine(&quot;The &#39;same&#39; -= operator took {0}ms.&quot;, operatorNoCtorMS);
          Console.WriteLine(&quot;The PlusEqual(double, double) method took {0}ms.&quot;, plusEqualDDMS);
          Console.WriteLine(&quot;The do nothing loop took {0}ms.&quot;, doNothingMS);
    
          // Compare speeds
          long percentageRatio = 100L * operatorCtorMS / plusEqualMS;
          Console.WriteLine(&quot;The ratio of operator with constructor to method is {0}%.&quot;, percentageRatio);
          percentageRatio = 100L * operatorNoCtorMS / plusEqualMS;
          Console.WriteLine(&quot;The ratio of operator without constructor to method is {0}%.&quot;, percentageRatio);
          percentageRatio = 100L * plusEqualDDMS / plusEqualMS;
          Console.WriteLine(&quot;The ratio of PlusEqual(double,double) to PlusEqual(Element) is {0}%.&quot;, percentageRatio);
    
          operatorCtorMS -= doNothingMS;
          operatorNoCtorMS -= doNothingMS;
          plusEqualMS -= doNothingMS;
          plusEqualDDMS -= doNothingMS;
          Console.WriteLine(&quot;If we remove the overhead time for the loop accessing the elements from the List...&quot;);
          percentageRatio = 100L * operatorCtorMS / plusEqualMS;
          Console.WriteLine(&quot;The ratio of operator with constructor to method is {0}%.&quot;, percentageRatio);
          percentageRatio = 100L * operatorNoCtorMS / plusEqualMS;
          Console.WriteLine(&quot;The ratio of operator without constructor to method is {0}%.&quot;, percentageRatio);
          percentageRatio = 100L * plusEqualDDMS / plusEqualMS;
          Console.WriteLine(&quot;The ratio of PlusEqual(double,double) to PlusEqual(Element) is {0}%.&quot;, percentageRatio);
        }
      }
    }

**The IL:** (aka. what some of the above gets compiled into)

    public void PlusEqual(Element that)
        {
    00000000 push    ebp 
    00000001 mov     ebp,esp 
    00000003 push    edi 
    00000004 push    esi 
    00000005 push    ebx 
    00000006 sub     esp,30h 
    00000009 xor     eax,eax 
    0000000b mov     dword ptr [ebp-10h],eax 
    0000000e xor     eax,eax 
    00000010 mov     dword ptr [ebp-1Ch],eax 
    00000013 mov     dword ptr [ebp-3Ch],ecx 
    00000016 cmp     dword ptr ds:[04C87B7Ch],0 
    0000001d je     00000024 
    0000001f call    753081B1 
    00000024 nop       
          this.Left += that.Left;
    00000025 mov     eax,dword ptr [ebp-3Ch] 
    00000028 fld     qword ptr [ebp+8] 
    0000002b fadd    qword ptr [eax] 
    0000002d fstp    qword ptr [eax] 
          this.Right += that.Right;
    0000002f mov     eax,dword ptr [ebp-3Ch] 
    00000032 fld     qword ptr [ebp+10h] 
    00000035 fadd    qword ptr [eax+8] 
    00000038 fstp    qword ptr [eax+8] 
        }
    0000003b nop       
    0000003c lea     esp,[ebp-0Ch] 
    0000003f pop     ebx 
    00000040 pop     esi 
    00000041 pop     edi 
    00000042 pop     ebp 
    00000043 ret     10h 
     public void PlusEqual(double thatLeft, double thatRight)
        {
    00000000 push    ebp 
    00000001 mov     ebp,esp 
    00000003 push    edi 
    00000004 push    esi 
    00000005 push    ebx 
    00000006 sub     esp,30h 
    00000009 xor     eax,eax 
    0000000b mov     dword ptr [ebp-10h],eax 
    0000000e xor     eax,eax 
    00000010 mov     dword ptr [ebp-1Ch],eax 
    00000013 mov     dword ptr [ebp-3Ch],ecx 
    00000016 cmp     dword ptr ds:[04C87B7Ch],0 
    0000001d je     00000024 
    0000001f call    75308159 
    00000024 nop       
          this.Left += thatLeft;
    00000025 mov     eax,dword ptr [ebp-3Ch] 
    00000028 fld     qword ptr [ebp+10h] 
    0000002b fadd    qword ptr [eax] 
    0000002d fstp    qword ptr [eax] 
          this.Right += thatRight;
    0000002f mov     eax,dword ptr [ebp-3Ch] 
    00000032 fld     qword ptr [ebp+8] 
    00000035 fadd    qword ptr [eax+8] 
    00000038 fstp    qword ptr [eax+8] 
        }
    0000003b nop       
    0000003c lea     esp,[ebp-0Ch] 
    0000003f pop     ebx 
    00000040 pop     esi 
    00000041 pop     edi 
    00000042 pop     ebp 
    00000043 ret     10h 

Why are operators so much slower than method calls?  (structs are slower only on older JITs)

We are making some `kNN` and `SVD` implementations in Python.  Others picked Java. Our execution times are very different. I used cProfile to see where I make mistakes but everything is quite [fine][1] actually. Yes, I use `numpy` also. But I would like to ask simple question.

    total = 0.0
    for i in range(9999): # xrange is slower according 
        for j in range(1, 9999):            #to my test but more memory-friendly.
            total += (i / j)
    print total

This snippet takes 31.40s on my computer.

Java version of this code takes 1 second or less on the same computer. Type checking is a main problem for this code, I suppose. But I should make lots of operation like this for my project and I think 9999*9999 is not so big number.

I think I am making mistakes because I know Python is used by lots of scientific projects. But why is this code so slow and how can I handle problems bigger than this?

Should I use a JIT compiler such as `Psyco`?

## EDIT ##

I also say that this loop problem is only an example. The code is not as simple as like this and It may be tough to put into practice your improvements/code samples.

Another question is that can I implement lots of data mining &amp; machine learning algorithms with `numpy` and `scipy` if I use it correctly? 

 


  [1]: http://wiki.python.org/moin/PythonSpeed/PerformanceTips

Content Type	Original Author	Original Content on Stackoverflow
Question	Mihai	View Question on Stackoverflow
Solution 1 - Lua	Ben Karel	View Answer on Stackoverflow

Why is LuaJIT so good?

Lua Problem Overview

Lua Solutions

Solution 1 - Lua

rake db:migrate doesn't seem to work in production

What file system path is used by Android's Context.openFileOutput()?

Attributions