The Dev Bootcamp Onsite Experience: Part 1

October 26, 2015

“Long days, short weeks.” Four words (not my own) that summarize the Dev Bootcamp onsite experience. While there was a certain amount of ebb and flow during the nine weeks, I can confidently say I learned much more than if I had just spent the nine weeks teaching myself. Plus, I made a bunch of new friends.

While I’m not allowed to get too much into the specifics of the curriculum due to its proprietary nature, I do believe I’m permitted to talk about it from a more abstract perspective. The nine weeks of the program are broken into thematic three-week phases, with each threshold between chunks serving as a waypoint toward jumping off into new topics that become progressively more reminiscent of actual professional web development as it’s currently practiced in industry.

Looking back through my hastily scrawled notes on the experience and my completed exercises, I feel that each three-week segment can be further divided into three smaller constituent parts. Or, in much similar terms, each week had its own individual theme, which I’ll summarize briefly below.

Week 1 – Algorithms

I would hazard a guess that when the average guy on the street thinks of programming, he envisions something like what we did during the first week. Lots of logic puzzles, lots of mathy stuff, lots of little games involving words and numbers. As I’ve mentioned previously, I’ve always been a big fan of games and puzzles (and math for that matter), so this week was right up my alley. But not everyone possesses this proclivity, so there was a high level of stress among the cohort in part due to the challenging material and in part due to the many late nights (and long weekends). Then again, one would expect a “bootcamp” to start off in a strenuous manner, so the material this week was certainly fitting!

Also of note, this was the week when I first experienced a phenomenon I like to call code churn, that is, when you wake up multiple times in the middle of the night to jot down thoughts you have on how to improve upon the code you wrote earlier in the day (or ideas about how to solve the problem you couldn’t quite finish the day before). This was not the only week at Dev Bootcamp during which I experienced code churn.

Week 2 – Design Principles and Data Parsing

Perhaps the most interesting thing about this week to me was that it elicited an intriguing conversation about concreteness vs abstractness. Many in the cohort expressed relief that this week felt “less abstract” than the previous one, which personally struck me as very odd because I’m definitely in the Descartes camp—after one’s own thoughts, there is perhaps nothing more concrete in this world than mathematical truths. If anything, this week, when we dove into the design principles widely adopted by programmers, felt more theoretical and abstract to me. But I digress.

From what I’ve heard about Dev Bootcamp’s ever-changing curriculum, our cohort was one of the first to explore Object-Oriented Design during Phase 0, which may or may not have had life-altering consequences on my coding style. As such, much of the material was review, and it definitely made more sense when encountering it the second time around. We were also introduced to the most prevalent design pattern used in web development, Model - View - Controller (MVC). Ruby on Rails leverages this pattern, and it also exists in about a million different flavors of JavaScript. But what was (relatively) new and most exciting for me was learning how to parse and extract data from different file types and even web pages, which has even more practical uses than there are MVC JavaScript frameworks.

Week 3 – Databases

Databases aren’t very sexy. But they are ubiquitous. And therefore immensely important.

This week was all about databases, well, except for the assessment which wasn’t an assessment because that’s a word that puts undue pressure on people to perform but was nevertheless an assessment even if you don’t want to call it that. I like databases. They really appeal to my desire for order and organization, and it’s always fun to draw lines from one thing to another (in order to represent relationships between database tables) as this evokes pleasant memories from early childhood. In fact, the very positive experience I had designing a database application to better organize student data and streamline office procedures in a previous job was one of the things that led me into diving headfirst into software development.

All the same, I think talking about learning about databases in an engaging fashion is beyond even my powers. Instead I’ll quote one of my instructors who said that his favorite programming language was SQL (i.e. the database language) because “it’s the purest programming language of them all.” Earlier in the program, this same instructor also gave us the gem, “Everything that can be done by iteration can also be done by recursion and vice versa,” which was a really eye-opening statement, albeit one that you, the reader, probably won’t understand unless you have prior programming experience. But trust me when I say that those are two gnomic gems.

* * * * *

This concludes Part 1 of this massive blog post. Jump to Part 2 or Part 3.