Erik Reed

Antisocial coding

2026-08-07T04:22:39+00:00

I would have appreciated the human connection more had I known what would come. I miss being able to scroll through online content and knowing it was probably written by a human being. If not, it was obviously not. Music, video, and photos were likely real. Nice looking websites were meticulously crafted or plagiarized. Stack overflow and github were vibrant. People spent time on what they wrote and published.

Coding now is antisocial. There is no need to open a PR, post issues, comment on stackoverflow. It will be lost in the agentic ocean. There's no need to talk to anyone aside from your favorite model. Or reason to share, really. What you built and want to share is now built daily: it's easier and more fun to do it "yourself".

Open source as we knew it is over. The internet is as busy as ever yet it feels so stagnant. The zero barrier of entry makes everything look the same. There is little reason now to hone your craft.

Truly remarkable things are being built without the slightest bit of understanding by a human being, all while being done without any human interaction. If we're lucky, someone will use them. Soon we'll be lucky to even be aware of the things being built.

Not a singularity, no. Just noise pollution and consequent end of the internet being a source of human interaction.

Algorithmic Trip Planning (Part 2)

2015-03-23T05:34:00+00:00

My next trip is an adventure to the Middle East, prompted by a fare drop by Turkish Airlines. San Francisco to Istanbul via Turkish is a new route and fares were quite good relative to historical data (along with other critera), prompting a nifty algorithm to send me an email. Seeing $680 round-trip, I naturally bought the ticket.

Primarily three modifications of my previous algorithm allow for novelty:

Searching round trip fares when they are cheaper than one way; that is, introducing a round-trip fare when a route of one ways has a complementary OD pair (e.g. SFO -> HRG -> [intermediate cities] -> HRG -> SFO has a complementary/reversed OD pair)
Leveraging intermediate city fares, omitting the remainder of an itinerary (e.g. buying a ticket from Egypt to Hungary, but getting off at a layover in Turkey
Airport proximity: allowing different airport codes per city hop (e.g. flying into Cyprus' ECN, out of LCA, which is 45km away)

It turns out, including the above does not significantly increase the search space, which is a nice way to say, a linear penalty is miniscule if we're already at O(n!), where n is the number of airport codes. Consequently, with naive brute force enumeration, I find runtime to be sub-20 seconds via Pypy.

The full route is as follows:

San Francisco (SFO) -> Istanbul (IST) -> Hurghada (HRG) $680 — get off at IST
Istanbul (IST) -> Cyprus (ECN) $108
Cyprus (LCA) -> Tel Aviv (TLV) $76
Tel Aviv (TLV) -> Amman (AMM) — unknown: bus fare
Amman (AMM) -> Cairo (CAI) $184
Cairo (CAI) -> Hurghada (HRG) $103
Hurghada (HRG) -> San Francisco (SFO) — return flight

Total: $1150 (plus bus fare from Jerusalem to Amman).

I also had a few goals/constraints, which all were satisified:

No propeller aircraft — in this case, all A320s
Direct flights only
Reasonable departure times — i.e. no waking up early or arriving after 8pm

Definitely lots of opportunity for improvement computation/algorithm-wise — perhaps another trip will yield some insight.

Python constants to arguments

2015-02-25T21:53:00+00:00

A quick snippet to convert any primitive type constant in a Python main module to program arguments. E.g., if I have main.py with

FEATURE_SELECTION = True
NUMBER_OF_ROWS = 100

def main():
  # rest of program

and I want to trivially and automatically parse command line arguments to replace the constants, which is really a bad idea for a variety of reasons, an automatic argparser can generate this:

$ python main.py --help
usage: main.py [-h] [--number-of-rows NUMBER_OF_ROWS]
               [--feature-selection FEATURE_SELECTION]

optional arguments:
  -h, --help            show this help message and exit
  --number-of-rows NUMBER_OF_ROWS
                        Auto-generated constant (int). (default: 100)
  --feature-selection FEATURE_SELECTION
                        Auto-generated constant (bool). (default: True)

The following snippet can be appended to a main module to hackily replace the constants!

import argparse
parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter)
# update global constants with args
map(lambda kv: parser.add_argument('--%s' % kv[0].lower().replace('_', '-'), default=kv[1], type=type(kv[1]) if type(kv[1]) != bool else str,
                                   help='Auto-generated constant (%s).' % type(kv[1]).__name__, dest=kv[0]),
    filter(lambda kv: kv[0] == kv[0].upper() and type(kv[1]) in (int, bool), globals().iteritems()))
args = parser.parse_args()
globals().update(((k, eval(v) if type(v) == str else v) for k, v in vars(args).iteritems() if k == k.upper()))

And now, I can do:

$ python main.py --number-of-rows=10

without ever having to add logic specific to constants; I can just add constants and the flags are auto-generated.

Just be wary this is incredibly bad practice due to monkey patching and insecure due to the use of eval(). However for quick scripts, I find it to be effective.

Algorithmic trip planning

2014-08-09T05:44:00+00:00

I write this in Singapore, city number three in a ten city voyage obtained via brute force enumeration of route permutations for a set of cities I desired to visit in Southeast Asia. I ended up purchasing 11 one-way tickets, starting and ending in San Francisco. Here I'll describe my route and give a high level algorithm.

My route, which I generated algorithmically, is the following:

Depart from San Francisco, United States [Jul 30] (via Philippine Airlines)

Tokyo, Japan for 1 night (layover) [Aug 01] (via Jetstar Asia)
Manila, Philippines for 5 nights [Aug 05] (via Jetstar Asia)
Singapore, Singapore for 7 nights [Aug 13] (via Jetstar Asia)
Ho Chi Minh City, Vietnam for 4 nights [Aug 17] (via AirAsia)
Bangkok, Thailand for 4 nights [Aug 21] (via AirAsia)
Phuket, Thailand for 4 nights [Aug 26] (via AirAsia)
Kuala Lumpur, Malaysia for 3 nights [Aug 30] (via AirAsia)
Phnom Penh, Cambodia for 4 nights [Sep 03] (via AirAsia)
Jakarta, Indonesia for 5 nights [Sep 08] (via AirAsia)
Bali, Indonesia for 5 nights [Sep 14] (via Garuda Indonesia)

Arrive at San Francisco, United States [Sep 14]

The total cost of airfare was $1670 USD, a good majority of the cost coming from the two tickets out/into SFO (San Francisco). It is worth noting this cost isn't particularly optimal as the tickets were purchased only 6 weeks in advice, and fare prices during July/August tend to skyrocket.

Consider the traveling salesman problem (TSP) for this scenario: given N=10 cities, find the optimal route that reaches all cities (without revisiting) which minimizes some cost function. In this case, the TSP search space can be amended to include a few more dimensions that influence cost. Most importantly, these dimensions are outbound date and time until departure (i.e. days in advance a ticket is purchased), as prices heavily fluctuate based on these factors. Using historical data, one can build a model and predict the fare prices as well as time to buy, however that's not the focus here (although worth a separate discussion). Quite simply, pick your favorite regression to do this. Additionally I imposed a days-per-city constraint: I wanted to spend between a=4 and b=8 days per city, so this was included as a per-city dimension.

I implemented the above in Python using historical data of Adioso, whom have the best fare coverage over Southeast Asia–although as a data scientist at Adioso, I am biased. I generated a couple dozen candidate routes and programmatically validated the fares (prioritizing direct flights), and purchased the "best" route by hand.

Once my trip is farther along or complete, I'll point out some pros and cons of this approach and describe two philosophies I have used for traveling: stochastic local search and global optimization (a la the traveling salesman problem).

Foo/bar decreases readability

2014-06-29T23:12:00+00:00

I think using foo or bar in code snippets is detrimental when visually parsing the code–especially when the syntax is unfamiliar. For example, I was browsing through some php code samples to find this:

foreach ($bar as $foo) {
    // do some stuff with $foo
}

Great. Now, say I don't know php; is foo an element or the array? From the comment, it's the array. Then I alt-tab, scroll through some code, and immediately lose 80% of what I gleaned from the context switch, only recalling "bar as foo". That means absolutely nothing. But if the snippet avoided the non-informative foobar usage, it would be so much more intuitive.

foreach ($files as $file) {
    // do some stuff with $file
}

Files as file… I'll remember that easier than "foo as bar". Using some simple, practical variable names makes example code more clear. Applying this to a function:

void foo(int bar1, int bar2);

versus

void func(int arg1, int arg2);

Another foo-embedded code snippet:

xargs -ifoo sh -c 'tar zxvf foo.tar.gz && mv $(echo foo | sed s/-.*$//) foo'

Now why not have "file" instead of "foo"? It probably would make more sense.

MATLAB image rotate without black bars

2014-04-06T15:32:00+00:00

MATLAB fills the empty region of rotated images with solid black (i.e. zero padding). This is rather problematic for various computer vision algorithms (e.g. fusion, registration, similarity). Unfortunately, this is not a parameter in the imrotate command. The following addresses this issue.

img = imread('cameraman.tif');
rotated = imrotate(img, 45, 'bicubic');
crop_upper = max(find(diag(rotated) ~= 0));
crop_lower = min(find(diag(rotated) ~= 0));
crop_diff = crop_upper-crop_lower;
rotated2 = imcrop(rotated, [crop_lower, crop_lower, crop_diff, crop_diff]);

% visualize
subplot(1,3,1)
imshow(img)
subplot(1,3,2)
imshow(rotated)
subplot(1,3,3)
imshow(rotated2)

This is similar to roirotate, but without explicitly declaring a region of interest or dealing the possibility of any zero-padding (black bar).

Miscellaneous useful Bash/shell commands

2014-01-19T02:27:00+00:00

I've been cataloging various shell commands and scripts that have been quite useful for various Linux (and even Windows via cygwin/git-shell) activities. The ones I list here are either not found via Google search or required a bit of hackery to suit my purposes.

Add a copyright (or author) comment to a bunch of Java files.

find src -type f -exec sh -c "sed -i '1s/^/\/\/ Copyright 2013 Erik Reed (erik@somewhere.com)\n\n/' {}" \;

Result:

// Copyright 2013 Erik Reed (erik@somewhere.com)

package java.com.tons.of.nested.packages.for.no.reason.coolapp;

import java.io.Serializable;
import java.text.ParseException;

// ...

Convert many image formats in parallel (jpegs to png here). Using 64 processes in this case:

find . -type f -name '*.jpg' -print0 | xargs -0 -n1 -P 64 sh -c 'convert "$1" "${1%.jpg}.png"' sh

Make file extensions lowercase (a common issue I've had with mixing Windows/Linux).

find . -name '*.*' -exec sh -c '
  a=$(echo {} | sed -r "s/([^.]*)\$/\L\1/");
  [ "$a" != "{}" ] && mv "{}" "$a" ' \;

Rsync files to/from remote machine as root (e.g. to backup multiple users, root owned files, or a full disk backup).

rsync -avze ssh --rsync-path='sudo rsync' myUser@REMOTE_SERVER:/REMOTE_PATH/ LOCAL_PATH

Clear disk cache and swap:

# clear cache
sync; echo 3 > /proc/sys/vm/drop_caches

# clear swap
swapoff -a; swapon -a

Print the mean and standard deviation of a file/stdin (in one line):

awk '{ sum += $1; sumsq += $1*$1 } END { printf "Mean: %f, Std: %f\n", sum/NR, sqrt(sumsq/NR - (sum/NR)^2) }'

NTFS compression is terrible for many small files

2013-02-24T10:15:00+00:00

Don't use NTFS compression for many small files.

I recently tried to enable NTFS compression on some log files to see how the compression ratio would fare versus batch compressing them all. I experimented with a 64MB folder with ~10k files and noticed a 1.4GB increase in disk usage. Interesting… let's take a look.

Pre-compression:

Folder properties:

Applying compression attribute:

Post-compression:

Nice, a 30% compression ratio (64MB to 45MB). Considering that each file is typically 1-4KB, I thought this was reasonable (compared to the batch compression ratio of 10:1). But, I noticed an odd increase in disk usage:

2.6GB down to 1.2GB. The only action taken was enabling NTFS compression on the above folder. Removing the compression attribute restores the lost 1.4GB of disk space.

This is surprising for two reasons: NTFS compression is supposed to be beneficial for small files (4-64KB) ^[1], and the folder properties don't alert the user to any extreme loss of disk space.

http://en.wikipedia.org/wiki/NTFS#File_compression ↩

Batch emailing a CSV file of data using Python and SMTP

2012-12-13T20:37:00+00:00

A quick script for sending a batch of emails using a csv file. Each csv line contains an email address and the information I wish to populate in the email content and send to a single recipient. In this case, I wanted to send grades out for a group of students using a spreadsheet of grades from Google docs (and with my Gmail). With cursory preprocessing, I put the data in this format:

Firstname1 Lastname1,userID1,91.7,0.979
Firstname2 Lastname2,userID2,60.8,0.061
...

Then, we can parse it and fire off our mailer with the following:

# erik reed
import smtplib
import csv
from time import sleep
from email.mime.text import MIMEText


FROM_ADDRESS = "ADD_ME@asd.com"
SMTP_SERVER = 'smtp.gmail.com:587'
SMTP_USER = "ADD_ME"
SMTP_PASS = "ADD_ME"


def mail(msg):
  server = smtplib.SMTP(SMTP_SERVER)
  server.starttls()
  server.login(SMTP_USER,SMTP_PASS)
  server.sendmail(FROM_ADDRESS, msg['To'], msg.as_string())
  server.quit()


f = open('grades.csv')
reader = csv.reader(f)
for row in reader:
  content = 'Hi ' + row[0].strip().split(' ')[0]
  content += \
''',\n\nThis is an automated message with your final exam grade. If
you have any questions regarding exam grade, see ***** if you
are in SV, otherwise talk to me. The average grade on the final
exam was 76% with a standard deviation of 12.5%.\n\n'''
  content += 'You received a ' + str(row[2]) + '%, corresponding to '
  content += 'the ' + str(float(row[3]) * 100) + 'th percentile.'
  content += '\n\nErik'

  msg = MIMEText(content)
  msg['To'] = row[1] + '@cmu.edu'
  msg['From'] = FROM_ADDRESS
  msg['Subject'] = 'Fastcode: exam grade for ' + row[1]
  msg.add_header('reply-to', FROM_ADDRESS)
  print msg.as_string()

  mail(msg)
  sleep(1) # pause after each email send
f.close()

This could be cleaned up a bit using better Python syntax, but it does the trick. Each email will look something like the following:

Hi Firstname1,

This is an automated message with your final exam grade. If
you have any questions regarding exam grade, see ***** if you
are in SV, otherwise talk to me. The average grade on the final
exam was 76% with a standard deviation of 12.5%.

You received a 45%, corresponding to the 2.0th percentile.

Erik

Web server cache warming by crawling sitemaps

2012-04-02T14:56:00+00:00

Background

Hosting a website on a home server, especially one with low traffic, can result in long response times when retrieving pages. Intuitively, it seems like high traffic should slow the response of a server, and that a server with no CPU load should be able to return web pages faster. But–high traffic servers have a cache advantage. When a user visits a page that has already been recently served, that page is fresh in memory. This is a definite bonus from having the web server retrieve the page from a hard drive, which can take many orders of magnitude longer in IO time ^[1].

The low traffic home server is at a disadvantage because it is serving little content. The CPU is mostly idle and pages aren't being frequently accessed, decreasing the probability that a page will already be in memory when a user requests it. This results in cache misses, forcing data to be retrieved from disk. It is also said that the cache is "cold". As an example of how bad this can be, this site takes 1-2 seconds longer to load after a recent reboot, forcing all web data to be accessed from disk.

There are many solutions to this. Notable methods are: the entire web directory could be allocated to ramdisk ^[2]; implement mem-caching in apache ^[3]; object code (or opcode) caching for server-side languages like PHP ^[4]; and setting expiration dates (expire headers) to allow caching on the client's browser ^[5].

I use opcode caching and expire headers to speed page load time, which are very easy to implement. But these don't ensure web data is in memory. Or at least, ensure that there is a decent probability pages are in memory. For my ancient server, retrieving data from disk is the most time consuming factor of page load. Further, I don't want caching to require memory like a process; the operating system's disk cache can be leveraged to provide a cache that is optional. That is, if I'm running a bunch of memory intensive code in the background, the operating system will automatically prioritize it instead of keeping web data in memory, since the cached data is regarded as free. This is demonstrated below by the command vmstat -m, where the cache column indicates that 101 MB of disk is in memory, but classifies as free memory (see ^[6]).

procs -----------memory---------- ---swap-- -----io---- -system-- ----cpu----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa
 0  0     43    573    141    101    0    0     5    20   25   18  1  1 90  7

Implementation

One way to leverage the operating system cache as described above is to crawl the website. Crawling the site forces the server to load all resources from the disk. If there is sufficient free RAM and the site is small, like most blogs, the entirety of the web data will sit in the operating system cache. In the domain of serving web content, this can be called cache warming, which is analogous to user-guided anticipatory paging ^[7] or pre-fetching.

Crawling a site is easy if you have a sitemap. Several programs can automatically generate them, including sitemaps specific to blogs like WordPress ^[8]. Mine is here, where the XML content is visible when viewing the source. Since sitemaps have a standardized format, the following commands can be used to grab the URL of every page to crawl:

wget -O - erikriffs.com/sitemap.xml | grep -E -o '<loc>.*</loc>' | sed -e 's/<loc>//g' -e 's/<\/loc>//g'

Output:

erik@erik-server ~ $ wget -O - erikriffs.com/sitemap.xml | grep -E -o '<loc>.*</loc>' | sed -e 's/<loc>//g' -e 's/<\/loc>//g'
--2012-04-02 14:29:38--  http://erikriffs.com/sitemap.xml
Resolving erikriffs.com... 98.234.52.166
Connecting to erikriffs.com|98.234.52.166|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 1641 (1.6K) [application/xml]
Saving to: `STDOUT'

100%[=======================================>] 1,641       --.-K/s   in 0s

2012-04-02 14:29:39 (93.0 MB/s) - written to stdout [1641/1641]

http://erikriffs.com/
http://erikriffs.com/latex-ieee-bibliography-error/
http://erikriffs.com/index/
http://erikriffs.com/matlab-parfor-performance/

Having obtained the list of URLs, this can be piped back into wget to download every page along with the resources required, like css, js, and images.

wget -O - erikriffs.com/sitemap.xml | grep -E -o '<loc>.*</loc>' | sed -e 's/<loc>//g' -e 's/<\/loc>//g' | wget -i - -p -r --delete-after

The above one-liner keeps web data fresh in the cache. Temporarily. As other activity occurs on the operating system, the amount of site content in memory will slowly decrease. Using crontab -e and the crawling one-liner allows for an hourly cache warming. It is also a far simpler alternative to a PHP program, and unlike this Drupal example, will crawl images and other dependent resources (the author is missing the -p flag in wget).

Latex IEEE bibliography error

2012-03-31T18:34:00+00:00

The IEEE Latex format is a nightmare to work with. Nothing new there. One problem I had was using the IEEE template with bibliography that had worked for other conference styles. Now all I get is a cryptic error:

Latex:

\bibliographystyle{IEEEtran}
% argument is your BibTeX string definitions and bibliography database(s)
\bibliography{IEEEabrv,isrcs12}

Console output:

...
("C:\Program Files (x86)\MiKTeX 2.9\tex\latex\sttools\stfloats.sty")
(C:\Users\Erik\Desktop\phd_stuff\papers\isrcs12_controlling_bns\isrcs12.aux)
(C:\Users\Erik\Desktop\phd_stuff\papers\isrcs12_controlling_bns\isrcs12.bbl

! LaTeX Error: Something's wrong--perhaps a missing \item.

See the LaTeX manual or LaTeX Companion for explanation.
Type  H   for immediate help.
 ...

l.24 \end{thebibliography}

?

I couldn't find the solution on Google and spent excessive time trying to figure out the issue only to discover:

@inproceedings{khanautomated2011,
   title={Automated Refinement of Bayes Networks' Parameters based on Test Ordering Constraints},
   author={Khan, O.Z. and Poupart, P. and Agosta, J.M.}
   booktitle={Twenty-Fifth Annual Conference on Neural Information Processing Systems (NIPS 2011)},
   year={2011},
   organization={Neural Information Processing Systems Foundation}
}

All tags must be followed by a comma. Unfortunately, there was no comma after one of my author tags (above), which seems to be pretty common. Normally this isn't an issue, but the IEEEtran bib-style can't handle minor syntactical issues without erroring out.

Slow MATLAB parfor (parallel for) performance and possible Parallel Toolbox bug

2011-10-14T18:53:00+00:00

After playing with the MATLAB Parallel Computing Toolbox (r2009a x64), I noticed what appears to be significant overhead when writing to an array in parallel, increasing the speed of a parallel for loop by over an order of magnitude. This effect isn't observed in other programming languages like C, demonstrated below. While testing this, I also came across repeatable behavior indicative of a bug in MATLAB (see last code block). These tests were performed using a 4 core Intel i5 with 8GB of memory.

First is a loop the sums the numbers from 1 to n, applying a reduction to the variable sum. This case is embarrassingly parallel and shows a fairly linear increase in speed with respect to number of cores.

n = 10000000;
sum=0;
fprintf('serial: ')
tic
for i=1:n
    sum = sum + i;
end
toc

sum=0;
fprintf('parallel: ')
tic
parfor i=1:n
    sum = sum + i;
end
toc

serial: Elapsed time is 8.241937 seconds.

parallel: Elapsed time is 2.531207 seconds.

Now, instead of using the loop counter to increment the variable sum, the elements of an array [1,2,…,n] are summed. This requires MATLAB to read from an array using 4 threads, one for each core. A linear speed increase is demonstrated (as expected) here as well.

n = 10000000;
data = 1:n; % array with elements [1,2,...,n-1,n]

sum=0;
fprintf('serial: ')
tic
for i=1:n
    sum = sum + data(i);
end
toc

sum=0;
fprintf('parallel: ')
tic
parfor i=1:n
    sum = sum + data(i);
end
toc

serial: Elapsed time is 9.642881 seconds.

parallel: Elapsed time is 2.705653 seconds.

Instead of reading from an array in parallel, an array is written to in parallel. Here there is a 7x slowdown when parallelizing the loop.

n = 10000000; % 10 million
data = zeros(1,n);

fprintf('serial: ')
tic
for i=1:n
    data(i) = i;
end
toc

data=zeros(1,n);
fprintf('parallel: ')
tic
parfor i=1:n
    data(i) = i;
end
toc

serial: Elapsed time is 0.618991 seconds.

parallel: Elapsed time is 4.359711 seconds.

Interestingly, this slowdown doesn't occur when using OpenMP in C; using multiple cores allows for a 26% speedup during the equivalent array allocation. This is not 4x since the majority of CPU time is spent waiting for the next cache line to be retrieved from memory since no time is spent computing.

#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
#include <time.h>

int main(int argc, char **argv) {

	int n = 200000000; //200 million
	int i;
	double* data = malloc(n*sizeof(double));
	clock_t start = clock(), diff;

	for (i=0; i<n; i++)
		data[i] = i;

	diff = clock() - start;
	free(data);
	int msec = diff * 1000 / CLOCKS_PER_SEC;
	printf("Serial: Time taken %d seconds %d milliseconds\n", msec/1000, msec%1000);

	data = malloc(n*sizeof(double));
	start = clock();
	#pragma omp parallel for
	for (i=0; i<n; i++)
		data[i] = i;

	diff = clock() - start;
	free(data);
	msec = diff * 1000 / CLOCKS_PER_SEC;
	printf("Parallel: Time taken %d seconds %d milliseconds", msec/1000, msec%1000);

	return 0;
}

Serial: Time taken 1 seconds 583 milliseconds

Parallel: Time taken 1 seconds 167 milliseconds

Here is one additional observation which, by itself, leads me to believe there is some form of bug in the MATLAB Parallel Computing Toolbox. Introducing an additional variable before each loop slows the serial code by nearly 29x. This doesn't make any sense as the variable isn't used in the loop and should have no effect on computation time whatsoever. But let's look at speed difference:

clear
n = 10000000;
data = zeros(1,n);

sum=0; % new, unused variable
fprintf('serial: ')
tic
for i=1:n
    data(i) = i;
end
toc

sum=0; % new, unused variable
data=zeros(1,n);
fprintf('parallel: ')
tic
parfor i=1:n
    data(i) = i;
end
toc

serial: Elapsed time is 17.926449 seconds.

parallel: Elapsed time is 4.477197 seconds.

This behavior is consistent and replicable. Simply commenting out the sum=0; radically changes the speed. There should be no difference, but try pasting the above code into a MATLAB editor and running the code, then the identical code without the sum=0;. Further, pasting the code directly into the MATLAB terminal does not produce a difference in speed for the serial code; only running from a MATLAB editor window produces this anomaly.