Content-Type: RST

Some of my friends here at college have started taking the
introductory class for C++, and one of them put the general opinion
thus: "C++ makes me love Python". Syntax-wise the jump from Python to
C++ is pretty terrible, indeed. However, I gave him the usual stuff
about how C++ is faster and more efficient. However, I'm not sure that
argument is valid anymore.

.. figure :: http://blog.opensourcenerd.com/upload/shocked-cat

I know, right? After telling him this is I wanted some
conclusive evidence that C++ is indeed faster, to better prove my
point. So, I rigged up a quick test. First, I got the names of all of Ubuntu's
system files and put them in "files.txt".
  
.. sourcecode :: sh

   $ find /usr > files.txt
   $ wc -l files.txt
   151246 files.txt
   
151246 lines, that's a fair number. Next, I run this Python script to
shuffle them:


.. sourcecode :: python

   from random import shuffle

   fnames = open('files.txt').read().split()
   shuffle(fnames)
   out = open('files.txt','w')
   for x in fnames:
       out.write(x+'\n')

   out.close()

Then, I wrote two versions of a **bubble sort**, the slowest kind of
"standard" sort algorithms, but easy to code. What it consists of is
looping over the list of items to be sorted, and if it finds any two
items that are out of order, it swaps them. If there were no swaps
done on an iteration, that means it's done, and it stops. I
implemented this in Python:

.. sourcecode :: python

   def bubble(names):
       swapped = False
       for i in range(0,len(names)-1):
           if names[i]>names[i+1]:
               names[i], names[i+1] = names[i+1], names[i]
               swapped = True
       return swapped
   
   names = open('files.txt').read().split()

   while not bubble(names):
       pass

   out = open('sorted.txt', 'w')
   for x in names:
       out.write(str(x) + '\n')
   out.close()

... and in C++:

.. sourcecode :: cpp

   #include <fstream>
   #include <vector>
   #include <string>

   using namespace std;

   bool bubble(vector<string*>& names)
   {
     bool switched = false;
     for(vector<string*>::iterator it=names.begin(); it<names.end()-1; ++it)
       if (**it > **(it+1))
         {
           string* tmp = *it;
           *it = *(it+1);
           *(it+1)= tmp;
           switched = true;
         }
     return switched;
   }

   int main()
   {
     ifstream in("files.txt");
     vector<string*> names;
     string x;
     while (in >> x)
       names.push_back(new string(x));


     while (!bubble(names))
       continue;

     ofstream out("sorted.txt");
     for(vector<string*>::iterator it=names.begin(); it<names.end(); ++it)
       out << **it << endl;
     out.close();
   }
   
Well, there's the code/syntax complexity everyone talks about. But
really, it's not *that* bad. Next, I compiled the C++ program:

.. sourcecode :: sh

   $ g++ sort.cpp -o sort

And, in the end, I ran both the programs with the "time"
command, which times their runtime, which in this case is an indicator
of how fast both sorted the list of file names. So, here is the result for
Python:

.. sourcecode :: sh

   $ time python sort.py 

   real   0m1.355s
   user   0m1.236s
   sys    0m0.084s

... and the one for C++:

.. sourcecode :: sh

   $ time ./sort
   Segmentation fault

Oops! Yeah, to be noted that I spent a ton more time debugging my C++
code because of these segfault errors. But in the end, it worked:

.. sourcecode :: sh

   $ time ./sort

   real   0m2.040s
   user   0m0.708s
   sys    0m1.332s

Here is a little breakdown of what these numbers mean:

  *real*: the sum of the other two, the total time the process took to
   run
  *user*: the amount of time the program spent actually running its
   own commands. When looping, this is what a program accumulates.
  *sys*: the amount of time spent processing by calls to the kernel on
   the program's behalf. For example, reading/writing a file counts
   here.

So, it would appear Python spent more time working itself than C++
did, but whatever C++ did under the surface was by *far* slower
than what Python did, looking at the "real" times. 

.. figure :: http://blog.opensourcenerd.com/upload/disbelief-cat

   Also when Python is faster than C++.

Now, I'm confused. Is Python really that efficient? No. I have
witnessed firsthand how my Mandelbrot fractal generator written in
Python was far out-paced by one written in C, and I know that C++ is
not any slower than C. Then? Was this test I devised wrong? Is Python
more efficient at string sorting than C++? Are there really instances
where Python can be faster?

Maybe my readers know...