We all have an origin story. Here's one of mine: how I became a programmer.
My first dabbling with computer programming began in middle school, as I passed the time in classes by programming a "guess what number I'm thinking of" game on my TI-83. It was a humble beginning and not particularly fun to play, but the magic of creating something from nothing captivated me. (Also, as it turns out, I informally re-invented the binary search algorithm.) By reviewing the code of other games loaded onto my calculator, I cobbled together My First Program. (Granted, it was little more than some print statements, a while loop, if statements, and input prompts, but we all have to start with "Hello World" at some point.) From there, I took an interest in the burgeoning and mysterious land of the Internet. Referencing source code and a tutorial here and there, I crafted my own Geocities page with raw HTML. I bravely eschewed their website builder, partly because I wanted to understand how it all worked, and partly because I thought the code generated from the builder looked horrendous.
My lazy tinkering continued in high school: attending a summer school class on Visual Basic 5.0 (haha), attempting to read through a C++ book (I got stuck on hex conversions -- why they put that so close to the beginning is beyond me; pedagogical techniques have advanced a lot since the early 2000's). I made a brief foray into scripting while building worlds for Neverwinter Nights. The prospect of computer programming interested me, but I didn't take the study seriously; my attention was generally consumed by school and computer games.
For a long time, I seriously wanted to enroll at DigiPen and become a game programmer. As explained in another post, I was dissuaded from that path. (I'm tempted to say "for the better," but one never knows for sure; indeed, my path is what it is; there can be no comparison because the other paths do not exist (omitting multiverses for the time being).)
This decision was made before programming became the sexy thing to do among engineers thanks to Google and Apple; from my perspective, that happened a few years later around 2007. Software engineers was still reserved for the bespectacled and socially awkward, people I generally imagined stuck as cogs in a massive machine like IBM. Further, any research into reviews of CS programs uncovered flaming rants, decrying the anachronisms of such curriculum and putting forth their general worthlessness. ("By the time you graduate, the languages you have learned will be outdated," they would say.) To be honest, my research into the actual working conditions of software engineers at that time was embarassingly shallow. But, I was a high school student, so there it is. With my decision set to study Civil Engineering at the University of Portland, I sealed my fate to not touch programming for many years.
In graduate school, I toyed with the idea of taking some computer science classes. I made it through auditing a few weeks of the introductory CS106A course, before it fell by the wayside in the face of my many other responsibilities in school.
It took precisely three events to precipitate my serious delving into programming: a breakup, an email, and a conversation.
In the fall of 2012, I moved out to New York City in pursuit of a new woman and a new full-time career in dance. I put everything on the line, taking a leave of absence from my very successful graduate studies at Stanford University. Six months later, neither was working out. I felt like I had lost my way, gone adrift by departing from the standard accepted path (college --> graduate school --> work), and needing some direction. Away from school and from a stimulating academic environment for too long, a listless depression had settled in my heart. Meanwhile, I had decided to eschew all television watching and video gaming, because it was serving as an escape that only intensified my torpor. The removal of a relationship, television, and video games left a massive vacuum in my schedule; I desparately needed something to occupy my time. Crashing at a friends place, mired in self-pity and -loathing, wondering what I could do to get back on track, I received the email.
Listlessly purusing my inbox at night pretending to be productive, I opened a promotional email from StartX, the Stanford startup accelerator, which announced its recent batch of companies, most of which were tech-based. It got me thinking about all the activity and excitement that the tech industry had been receiving, and led to my lamenting the decision to not go into programming. It felt like I had missed the boat, one that promised opportunity and flexibility. My head swarming with emotions, I uncharacteristically reached out to a programmer friend of mine from Stanford, a fellow resident from my cooperative, and engaged in the conversation.
What followed did not go as expected. As I cried, "Alas, alack, I've missed the boat," he returned: "No, you haven't; you can teach yourself up to a hireable level easily within a year. You don't even need a degree, as long as you can provide your skills." How could such an incredible claim be possible? Could such an industry really exist, one that is so much more a meritocracy than any other?
An hour later, I created an account with Codecademy and started learning. I went to sleep around 4am that night, against my great desire to keep working through material. I felt empowered and inspired. I was learning again, pushing myself for the first time in many months. I didn't necessarily expect to make a career out of it, I just enjoyed the heck out of doing it.
My foray into programming had, at last, begun in earnest.
On and off
The following year and a half saw progress in fits and spurts, largely dictated by my dance teaching schedule. I would go through periods where I hardly touched a line of code, busy as I was touring around the US and Europe. Other times, I would log 40, 50, 60 hours of coding in a week. I genuinely looked forward to such opportunities, for I loved to learn new concepts and complete new tasks. The progress was obvious: whether understanding a new algorithm or wrapping my head around functional programming, I steadily built my scaffolding to then grasp even more complex topics.
While my sense of progress was evident, my direction was not. I had the three "core" Stanford CS classes to serve as a guide: CS106A (Programming Methodologies, Java), CS106B (Programming Abstractions, C++), and CS107 (Programming Paradigms, C).
CS106A provided the perfect introduction to programming. Professor Sahami takes seriously the art of teaching. He would explain concepts clearly and often with my forms of learning (e.g. visualizations, analogies). He also was quite funny in class: showing up in costume, telling jokes, throwing candy at students that ask questions. (Also, though not because of his teaching style, some truly hilarious moments like this one.) Assignments were often game oriented, such as building Yahtzee.
In addition to being highly enjoyable, the course presented many critical building blocks of programming: encapsulation, decomposition, and object-oriented programming, to name a few. It's fun to look back upon my lecture notes and see how far I've come -- a long way from the humble
CS106B was the second step in my programming path. Bravely wading into C++ (despite the objections of peers at it being an "outdated" language), I learned about what runs under the hood of many programs. Data structures (arrays, queues, stacks, linked and doubly-linked lists, binary heaps, binary search trees) and data abstractions (vectors, maps, sets) were covered in the course, as we peeled off the top layer to see the mechanics running underneath. Other core topics included recursion strategies and algorithms. Working with C++ made me feel much "closer" to the machine, particularly once we began manipulating pointers. As far as content goes, this has been my best class: the concepts covered have stayed with me since then.
I never made it to CS107, sidetracked by other learning opportunities. While working through CS106B, I stumbled through a few different Coursera classes: Introduction to Programming (Python), Functional Programming in Scala, Programming Languages, and Algorithms.
The Python class was enjoyable, though nothing ground-breaking. Already having a sound background in the basics, I took this class more for the introduction to the language. It was fun and quick, and now I have some familiarity.
The Scala class cleaned the floor with my face. I had never encountered functional programming at that point, and this class did not have the best instructor to impart the concepts. The course was made doubly challenging by working with an utterly unfamiliar syntax. I'm glad I did it, passing the course with distinction, but it was a grueling process and probably not timed well.
Programming Languages came as the followup to the Scala course. Mirroring the course at University of Washington, it covered abstract concepts in programming languages centered around the exploration of a 2x2 matrix: functional vs. object-oriented programming, and static v. dynamic typing. We looked at three of the four.
Static Dynamic ------------------------ Functional | ML | Racket | ------------------------ OOP | Java/etc | Ruby | ------------------------
It was an advanced course, intended for second-year CS majors. The professor, Dan Boneh, didn't pull any punches with this material. While endeavoring to be clear and concise, he never dumbed down the approach. As it was, I'd say it was a little over my head at the time. Mixins, duck typing, parsers, double dispatch, structs, polymorphism, lambdas, closures, blocks, the list goes on and on, and many of them didn't quite stick. I don't feel terrible about this fact -- my guess would be many engineers couldn't throw down a double dispatch on the spot, so I'm not alone. But they're valuable tools and I will doubtless revisit the course later on to bolster my understanding.
The algorithms course, taught by Tim Roughgarden, the first half of the Stanford algorithms course CS161, was precisely what one would expect: a deep-dive into algorithmic analysis. A valuable class, taught quite well. My eyes tended to glaze over whenever mathematical symbols splayed onto the screen to provide a proof of correctness, but I managed my way through it. I'm pretty good at holding onto material long enough to make it through a class, even if it's difficult or unintuitive. It is, however, less likely to stick long-term in my mind. Without much occasion to regularly practice the random contraction algorithm, many finer points of the class have faded away.
A summer of web development
By the time I finished all these courses, an entire year had passed. I was living large as a nomadic dance instructor, working on weekends and coding during the weekdays from coffee shops around the world. It was a good life. Coding was still something I did for fun, as I held out for a reentry into the sustainable construction industry. But, as my time in programming had been so rewarding, and the work style can fit quite nicely with a traveling instructor, I began to open up my mind to the possibility of working professionally. Meanwhile, I was growing concerned about ever-lengthening time away from the engineering industry, and wondering if the black hole of no work experience on my resume would mar me forever. Thus the stage was set for yet another significant email to cross my inbox.
In late April of 2014, I happened upon an internship posting, forwarded through the many mailing lists of Stanford. Gmail had flagged it as "unimportant." Procrastination had me picking my way through those messages, and dumb luck had me open it and take it seriously. An internship at a SF-based sustainability startup, looking for engineers with experience in building systems and energy, sustainability, and programming. What could be a better fit? After some debating whether it really was time for a re-entry into the engineering field, I dusted off my resume, spent many hours on a cover letter, and submitted my application bundled with a healthy dose of hope. A few weeks and a rather crazy story later, I had landed the internship.
I was accepted to Hack Reactor shortly after the news arrived about Carbon Lighthouse. June was, needless to say, a heady time for me. Everything was feeling on the up and up: here I was, wrapping up a successful 3-month tour of Europe, about to gain real-world programming experience and a sustainability startup and then join a prestigious bootcamp to massively expand my skillset and become a bonafide software engineer. Hack Reactor offered the "stamp of approval" that I desparately sought (since I could not look to a B.S. to provide it), some reasonable "guarantee" that I'd actually get a job. I could hardly contain myself.
The internship was a dream come true, but I'll skip to the pertinent bits for this story.
Part of the challenge (and the fun) of the internship was knowing what I wanted to do, but having no clue how to get there. Sometimes the path was straightforward; for example, I needed to be able to manipulate objects on the page, so I took some online courses on jQuery through CodeSchool. (CodeSchool came quite in handy for much of my base knowledge in web development. I already had a subscription before the internship, and used it heavily during my time there.) But other times, the path was like walking through a dark forest without a flashlight, guided only by the occasion faint whistle to steer my path.
Despite the challenging circumstances, I grew a lot through the process and achieved most of the original project objectives. I had built a mostly functional product. It did not integrate with existing Excel workflows, did not provide the backend that I had hoped, did not yet have error-proof offline storage and syncing. But it worked, and it could be tested by engineers in the field, and I'm exceedingly proud of that fact. Plus, when I demoed it to the group, they all ooh'ed and ahh'ed at the appropriate times. I had clearly done a fine job identifying their pain points, iterating regularly and always driving toward the design requirements, and delivering a well-informed and thoughtfully architected solution.
The road to Hack Reactor
I walked out of my internship feeling like a bonafide front-end web developer. My time had Carbon Lighthouse was its own sort of bootcamp, and I had benefitted enormously from it. It bolstered my confidence in the path I had taken, and that I could indeed get a job as a software engineer. I even became convinced that I could achieve it on my own, with several more months of hard work and diligence. No longer believing that I "needed" Hack Reactor to get a job, I spent a long and hard time deliberating if it was still worth it. In the end, I decided it was.
Since the conclusion of my internship in mid-October (technically it was a summer internship, but I started in late June and took off an entire month for other teaching work that was previously booked), I have been blasting through the precourse material for Hack Reactor. It's all stuff I've experienced before, so I took great pleasure in finishing the basic requirements with ease and then digging into the extra credit material, or going even beyond and inventing my own ways to continue learning on the topic. For example, after going through the Backbone courses on CodeSchool, I revisited a webpage built for one of the assignments and refactored everything using the new framework.
Which brings me to now: flying from Amsterdam back to the United States, Hack Reactor less than a week away. It's amazing to see how far I've progressed, and I'm glad for the occasional blog post I've written along the way to document my path. I still distinctly remember my first time implementing recursion in the first CS106A homework assignment -- long before recursion would be discussed in class -- based upon an exceedingly vague recollection of recursion from my summer school class in high school.
Now it's time to become a professional software engineer.