user4396: I was wondering why there is a 15 ms delay between each iteration of a the main loop.
Code:
The following code shows the execution time expressed in microsec between each loop
void setup()
{
  Serial.begin(9600);
}

void loop()
{
  Serial.println();
  Serial.print("Start: ");
  Serial.print(micros());
  Serial.print("/////////////////////");
  Serial.print("End:");
  Serial.print(micros()); 
}

Output:
Start: 789452/////////////////////End:821692
Start: 837292/////////////////////End:869532
Start: 885132/////////////////////End:917372
Start: 932972/////////////////////End:965212

Arduino needs 32,240 msec to print the messages to serial and to call the micros() function twice. And this it's fine. Now, considering the difference between the values of the End and the following Start, one question arises:
What does Arduino do between each loop?

user7508: TL;DR: The delays you measure (32.24 ms between Start and
End, and 15.6 ms between End and Start) are exactly what
is expected from the amount of data you send through the serial port.
Yes, exactly: there is zero overhead from the CPU doing other things.
Let me show how the expected timings can be computed. First, a note
about the exact baud rate. A rate of 9600 bps implies that each bit
takes about 104.17 µs to send. However, the Arduino being clocked
at 16 MHz, it cannot achieve this exact baud rate. Instead, when
you request 9600 bps, you get the closest value it can achieve,
which is about 9615 bps. Then, each bit takes exactly
104 µs. Or at least “exactly” as per the Arduino clock: it really
takes 1664 CPU cycles.
Then, as already noted in previous answers, one character is worth
10 raw bits. It thus needs 1040 µs to be transmitted.
Now, let's look at your code. It should be noted that
Serial.print(micros());

is compiled into something equivalent to
unsigned long timestamp = micros();
Serial.print(timestamp);

i.e. the timestamp is taken and then it is transmitted. Your loop()
is then equivalent to:
void loop()
{
    Serial.println();                       //  2 chars: CR and LF
    Serial.print("Start: ");                //  7 chars
    unsigned long time_start = micros();
    Serial.print(time_start);               //  6 chars
    Serial.print("/////////////////////");  // 21 chars
    Serial.print("End:");                   //  4 chars
    unsigned long time_end = micros();
    Serial.print(time_end);                 //  6 chars
}

By folding the last Serial.print() of one iteration into the beginning
of the next one, one gets the pseudo-code:
forever {
    print 15 chars;  // 15*1040 = 15600 µs
    read time_start;
    print 31 chars;  // 31*1040 = 32240 µs
    read time_end;
}

The computed durations match exactly your printout. This shows that,
once the Serial output buffer is full, the timing of your code
execution is completely governed by how fast the UART sends the bits out
the line. The time taken by the Arduino to do actual CPU work (calling
micros(), formatting numbers...) is irrelevant because the CPU works
in parallel with the UART and, being faster, it ends up waiting for
the UART anyway.

user1585: Your code is slightly off if you want to accurately time this
Serial.print("End:");
Serial.print(micros()); 

Will get micros() before printing to serial, and then take the time to print it. You also print some text before taking the time at the top of the loop. Your 15 ms is the time to print these to serial between reading micros. For example, change the loop code to something like this:
uint32_t time, endTime;
...
void loop(){
    time = micros();

    Serial.print(endTime);
    Serial.print('\t');
    Serial.print(time);
    Serial.print('\n');

    endTime = micros();
}

and you should only see a small difference. It showed a 4 microsecond difference when I ran it. The only other thing that runs outside the loop is the serial event handlers, but if you don't use one it obviously doesn't take long. 

user2881: Just check the sourcecode
for (;;) {
    loop();
    if (serialEventRun) serialEventRun();
}

So it does a check if serialEventRun is True, and then a jump back to the beginning of the for-loop. And then a call to loop.
Also note that Serial.print is blocking if the TX-buffer is full. So you might want to add a delay somewhere to ensure the buffer is never full.

user3031: Your serial connection is set to 9600 baud, which is 9600 actual data bits per second. The communication consists (*) of 8 bit characters and every bit is useful data (no parity), so you would be able to achieve at most 9600 / 8 = 1200 characters per second. 
You have a message of 46 characters including the line break, which brings you to 1200 / 46 = 26 iterations per second.
1000 milliseconds / 26 iterations = about 39 milliseconds per iterations.
This is the theoretic maximum you would get if you would send the data over serial without any other overhead. Pretty close to the 32 + 15 = 47 milliseconds you measured.
Since you print a part of the message (Enter + 'Start:') between the end of the previous iteration and the start of the next (if you take the call to micros() as the start and end), it makes sense that a part of the time is in between there as well.
So the actual overhead you are looking at is about 8ms per iteration. This delay is spread out over the loop and the call overhead of the various functions you use. After all, when you call Serial.print, a lot of work needs to be done before the data can actually be sent to the serial port. You would probably gain more speed/less overhead if you would construct one big string, and send it with a single print command.
Arduino itself is slow, but still much faster than this. It should be able to do a big(ger) number of iterations per second, but you basically limited it by initialising the serial connection to such a slow speed. You can partially eliminate this by picking a higher number. I think both your Arduino and any modern serial port should be able to handle 115200 baud. Nevertheless, you will always have a relatively big overhead when you are sending data over serial. Use your bandwidth wisely, and reduce the number of calls to Serial.print as much as you reasonably can.
*
) 8 bit, no parity is the de facto default. See Serial.begin() for more information about initializing the serial connection.

4396: <p>I was wondering why there is a 15 ms delay between each iteration of a the main loop.</p>

<p><strong>Code</strong>:
The following code shows the execution time expressed in microsec between each loop</p>

<pre><code>void setup()
{
  Serial.begin(9600);
}

void loop()
{
  Serial.println();
  Serial.print("Start: ");
  Serial.print(micros());
  Serial.print("/////////////////////");
  Serial.print("End:");
  Serial.print(micros()); 
}
</code></pre>

<p><strong>Output</strong>:</p>

<pre><code>Start: 789452/////////////////////End:821692
Start: 837292/////////////////////End:869532
Start: 885132/////////////////////End:917372
Start: 932972/////////////////////End:965212
</code></pre>

<p>Arduino needs 32,240 msec to print the messages to serial and to call the micros() function twice. And this it's fine. Now, considering the difference between the values of the End and the following Start, one question arises:</p>

<p>What does Arduino do between each loop?</p>
 7508: <p><strong>TL;DR</strong>: The delays you measure (32.24&nbsp;ms between <code>Start</code> and
<code>End</code>, and 15.6&nbsp;ms between <code>End</code> and <code>Start</code>) are <strong>exactly</strong> what
is expected from the amount of data you send through the serial port.
Yes, exactly: there is <em>zero overhead</em> from the CPU doing other things.</p>

<p>Let me show how the expected timings can be computed. First, a note
about the exact baud rate. A rate of 9600&nbsp;bps implies that each bit
takes about 104.17&nbsp;µs to send. However, the Arduino being clocked
at 16&nbsp;MHz, it cannot achieve this exact baud rate. Instead, when
you request 9600&nbsp;bps, you get the closest value it can achieve,
which is about 9615&nbsp;bps. Then, each bit takes <em>exactly</em>
104&nbsp;µs. Or at least “exactly” as per the Arduino clock: it really
takes 1664&nbsp;CPU cycles.</p>

<p>Then, as already noted in previous answers, one character is worth
10&nbsp;<em>raw</em> bits. It thus needs 1040&nbsp;µs to be transmitted.</p>

<p>Now, let's look at your code. It should be noted that</p>

<pre><code>Serial.print(micros());
</code></pre>

<p>is compiled into something equivalent to</p>

<pre><code>unsigned long timestamp = micros();
Serial.print(timestamp);
</code></pre>

<p>i.e. the timestamp is taken and <em>then</em> it is transmitted. Your <code>loop()</code>
is then equivalent to:</p>

<pre><code>void loop()
{
    Serial.println();                       //  2 chars: CR and LF
    Serial.print("Start: ");                //  7 chars
    unsigned long time_start = micros();
    Serial.print(time_start);               //  6 chars
    Serial.print("/////////////////////");  // 21 chars
    Serial.print("End:");                   //  4 chars
    unsigned long time_end = micros();
    Serial.print(time_end);                 //  6 chars
}
</code></pre>

<p>By folding the last <code>Serial.print()</code> of one iteration into the beginning
of the next one, one gets the pseudo-code:</p>

<pre><code>forever {
    print 15 chars;  // 15*1040 = 15600 µs
    read time_start;
    print 31 chars;  // 31*1040 = 32240 µs
    read time_end;
}
</code></pre>

<p>The computed durations match <em>exactly</em> your printout. This shows that,
once the <code>Serial</code> output buffer is full, the timing of your code
execution is completely governed by how fast the UART sends the bits out
the line. The time taken by the Arduino to do actual CPU work (calling
<code>micros()</code>, formatting numbers...) is irrelevant because the CPU works
<em>in parallel</em> with the UART and, being faster, it ends up waiting for
the UART anyway.</p>
 1585: <p>Your code is slightly off if you want to accurately time this</p>

<pre><code>Serial.print("End:");
Serial.print(micros()); 
</code></pre>

<p>Will get micros() before printing to serial, and then take the time to print it. You also print some text before taking the time at the top of the loop. Your 15 ms is the time to print these to serial between reading micros. For example, change the loop code to something like this:</p>

<pre><code>uint32_t time, endTime;
...
void loop(){
    time = micros();

    Serial.print(endTime);
    Serial.print('\t');
    Serial.print(time);
    Serial.print('\n');

    endTime = micros();
}
</code></pre>

<p>and you should only see a small difference. It showed a 4 microsecond difference when I ran it. The only other thing that runs outside the loop is the serial event handlers, but if you don't use one it obviously doesn't take long. </p>
 2881: <p>Just check <a href="https://github.com/arduino/Arduino/blob/master/hardware/arduino/cores/arduino/main.cpp#L42-L45" rel="noreferrer">the sourcecode</a></p>

<pre><code>for (;;) {
    loop();
    if (serialEventRun) serialEventRun();
}
</code></pre>

<p>So it does a check if serialEventRun is True, and then a jump back to the beginning of the for-loop. And then a call to <code>loop</code>.</p>

<p>Also note that Serial.print is blocking if the TX-buffer is full. So you might want to add a delay somewhere to ensure the buffer is never full.</p>
 3031: <p>Your serial connection is set to 9600 baud, which is 9600 <em>actual data</em> bits per second. The communication consists <em>(*)</em> of 8 bit characters and every bit is useful data (no parity), so you would be able to achieve at most 9600 / 8 = 1200 characters per second. </p>

<p>You have a message of 46 characters including the line break, which brings you to 1200 / 46 = 26 iterations per second.</p>

<p>1000 milliseconds / 26 iterations = about 39 milliseconds per iterations.</p>

<p>This is the theoretic maximum you would get if you would send the data over serial without any other overhead. Pretty close to the 32 + 15 = 47 milliseconds you measured.</p>

<p>Since you print a part of the message (Enter + 'Start:') between the end of the previous iteration and the start of the next (if you take the call to <code>micros()</code> as the start and end), it makes sense that a part of the time is in between there as well.</p>

<p>So the actual overhead you are looking at is about 8ms per iteration. This delay is spread out over the loop and the call overhead of the various functions you use. After all, when you call Serial.print, a <em>lot</em> of work needs to be done before the data can actually be sent to the serial port. You would probably gain more speed/less overhead if you would construct one big string, and send it with a single print command.</p>

<p>Arduino itself is slow, but still much faster than this. It should be able to do a big(ger) number of iterations per second, but you basically limited it by initialising the serial connection to such a slow speed. You can partially eliminate this by picking a higher number. I think both your Arduino and any modern serial port should be able to handle 115200 baud. Nevertheless, you will always have a relatively big overhead when you are sending data over serial. Use your bandwidth wisely, and reduce the number of calls to Serial.print as much as you reasonably can.</p>

<p>*
<em>) 8 bit, no parity is the de facto default. See <a href="http://arduino.cc/en/Serial/begin" rel="noreferrer">Serial.begin()</a> for more information about initializing the serial connection.</em></p>
