Week Two at Hack Reactor flew by really quickly! On a very high level, here's what we went over during the second week:

  • Self-Assessments + Sprint Reflection
  • Toy Problems
  • Inheritance Patterns:
    • Functional
    • Functional-Shared
    • Prototypal
    • Pseudoclassical
  • The N-Queens Problem.
  • Data Visualization with D3.js

Let's turn it up to eleven.

The second week onward at Hack Reactor is very different from the first. During the first week, we attended dozens of lectures and went through some recap of our pre-course work. Starting in the second week, the material is all-new and moves at a much faster pace.

Let's talk about sprints for a moment. During the first week, our only 'real' sprint containing new information was on Data Structures, which lasted four days. The second week (and, for the foreseeable future, onward) consists of one new sprint every two days. It's a lot of material to cover!

Our sprints contain what I like to consider the actual theme of the sprint itself, which revolves around real work experience and autonomy. For example, one of the sprints we worked on had to do with jQuery and Subclassical Inheritance in Javascript objects. It was a really fun assignment and there was so much free scope in what we could implement, so our goal was to understand that during these two-day sprints there is only so much that we can accomplish and to focus on the basic requirements first without being boggled down by all the extra features.

Another example that I felt was really helpful was when we built a a basic arcade game using the D3 visualization library. D3 was a really foreign library to most (if not all) of us, and our goal for the sprint was to learn how to approach new libraries by first understanding exactly what we needed to use from it in order to develop our project and not get overwhelmed by the abundance of available documentation.

Self-Assessments

Every Monday, we're given a Self-Assessment. Think of it as a timed (~60-minute) test on the sprints we covered the week before. There aren't any curveballs thrown, and the Self-Assessment is how we measure our progress while in the program.

Hack Reactor staff uses it evaluate our progress and it's a good way to test yourself and figure out what you need to go back and study on from the previous week.

Unlike a test that you would take in the traditional school system there isn't a clear 'pass' or 'fail' number, just like how it would not exist on the job as a software engineer.

Sprint Reflection

Sprint Reflections happen the morning after every sprint that we've completed, after that morning's Self-Assessment or Toy Problem. This is basically an open forum where we start by telling HR staff 'nouns' on what we want to vote on (i.e. 'The material covered in the sprint', a specific lecture we received, facilities on our floor, etc). Staff then sends out a survey immediately and we vote on each item, ranking them on a scale from 1-10. After we vote, we spend about ten to fifteen minutes with our pair partner from this previous sprint and give each other constructive feedback on how the pairing experience went.

Once this is over, we meet up to go over the voting results and give our opinions on them. Hack Reactor says Sprint Reflection has been the catalyst for a large portion of changes to its rapid-iteration teaching style. For example we receive a Solution Lecture video at the end of each sprint. As part of our Sprint Reflection feedback, Hack Reactor began implementing a Town Hall forum that takes place roughly one hour after the Solution Lecture video is released where students can submit questions on Google Moderator and then participate in-person and clear up any confusion or extra credit questions they had regarding the sprint.

Toy Problems

We started doing Toy Problems in the second week. These are interview-caliber algorithms that aim to prepare us for our job search. Every morning (with the exception of Monday, since we have a Self-Assessment on that day), we receive a Toy Problem solution lecture given by one of our Hackers-In-Residence (a recent Hack Reactor graduate who works for the school part-time for three months while continuing to work on their own projects to boost their portfolio before joining the job search at the end of their residency) before the current day's Toy Problem is released.

Inheritance Patterns

Javascript is a functional, object-oriented language. Implementing classes in JS is a very important factor. We explored the four different ways to create classes in JS during our Data Structures sprint from last week and went further with Subclassing this week (I will specifically write about Subclassing in a separate technical post).

My colleague Ryan Atkinson has a really great blog post on instantiation patterns that explains it extremely well and I recommend everyone give it a read -- open it in a new tab and come back here when you're done!

N-Queens

The N-Queens problem is an algorithm challenge that aims to answer the question: On an NxN chessboard, how many different solutions can you find that would allow you to place N Queens on it without causing any of them to be in conflict?

N-Queens was very fun and challenging. I partnered up with Mike Donaue on this sprint and we had a really fun time making our solution work. I'm going to try and write a technical post on this sprint if I can find the time to do so.

Wrapping Up

We also had a sprint involving D3.js this week, but I feel like I said all I needed to about this sprint above. This is a very fun, different library in JS that I don't feel like I have enough experience in but would like to on my free time.