Well, I started working on Dropbox because I kept forgetting my thumb drive.
And eventually I just got sick of having this problem and I wanted to
solve it permanently, first for myself, but then it was clear that many other people
would be were dealing with a lot of the same issues. So it was on
this one bus ride where I forgot my thumb drive at home. This was 2006.
I had my laptop with me, but I realized that I didn't have my thumb
drive and so I was super frustrated. And this was before the iPhone. You didn't
have WI FI on the bus. So I had something like four hours of
time to kill. And so I opened up the editor and started writing some Python
code. Not really envisioning starting a company or anything, but really
just to mechanically solve this problem of never carrying around my thumb drive again.
And the first few lines of code were basically around,
all right, I need to watch a folder or a directory
for changes, and anytime a file changes, I need to identify the change and
sync the difference up to a server. If you think about Dropbox, it's a
cross platform piece of software by design and by necessity.
Dropbox helps you sync your files across Windows and Mac and Linux.
So if you think about it, the conventional way to do that would have been
to build a Windows version in C and use the
Win32 API and use a different stack for Mac and a different
stack for Linux. I didn't have time for that. So I was
hoping and kind of praying that I could be able to write
one version of the app that would run anywhere. This was mainly out of necessity
because I was just one person. And then I partnered up
with my co founder shortly thereafter. But then there were two people. So my co
founder is basically writing the server of Dropbox and I was writing the client
software. And the conventional way to do it would have been to have to be
like in very low level systems code on all these different platforms.
But with Python, my hope, and with
the little bit of experience I had, I'd used Python on every major operating system
and it broadly worked the same way. And in general I could write a script
on Windows and have it run on Linux and vice versa.
But Dropbox was also very tightly integrated in the operating system, so that posed a
bit of a challenge because we still needed the capability and
the performance and these really tight integrations with the operating system. But. But I
just started writing in Python and hoping that none of the roadblocks would completely
blow me up. So the BASIC architecture was like I had the main version of
the app, which was OS OS agnostic. It had the basic syncing
logic. And then there were operating system specific backends for
each of the major operating systems. But I was always concerned, like,
hey, are we going to have performance problems? Because it's an interpreted language,
There was no precedent. So when you've used, if you
download Firefox or something back then it would be a broadly compiled
or the core of the app would be written in the operating
system native language or something that's C or C. And then
there are other challenges, like Dropbox would have to be multi threaded because there's a
lot going on simultaneously. One thread would be talking to the network, another might be
reading the hard disk, another might be doing a lot of sync engine logic.
And fortunately, Python had solutions for each
of those problems. I didn't know it at the time, I had to kind of
walk into the jungle and hope that I could get out the other side.
But there were a lot of benefits from, in addition to just the expressivity
of the language itself, lending itself to clean
design, then there was also a really mature standard library.
And so a lot of other programmers had figured out all the
contours of the different operating systems and had kind of batteries included
on every platform. And then from some of the trickier things around multi
threading, even things like memory usage or
optimizing memory usage, and then these
deep OS integrations or things that were pretty CPU intensive, like these
hashing algorithms or compression or encryption,
either there was a library available for, that was usable,
that already had a binding for Python, or I could take something that was in
C and wrap it with a Python binding. And so fortunately we just started
marching and then there was a lot of navigating around little different
potholes, but it ended up being probably the best technical decision we ever made
to use Python.