Booting Up: Bootcamp Weeks 1-5
Tags: beginners, bootcamp, codenewbie, ruby
Published: 2019-11-07 21:51:37

#Hello Friends!

I wanted to cover some ground on the first 5 weeks of my software engineering immersive bootcamp at Flatiron.

If you want to see Week 6, click [here](https://dev.to/shawnhuangfernandes/booting-up-week-6-project-week-25pf).

#Blog Overview

- What I learned
- Challenges I faced
- Learning Strategies

Naturally, I'll be covering 5 weeks in one blog post, so I will be summarizing pretty heavily! Every blog post after this will cover weekly installments, and will be more in depth!

#Week 1: Introductions & Ruby Basics

Coming into this program, I got to meet all the other members of our cohort (roughly 10 people). We met our instructors, coaches, and set up our work stations. We also began reviewing programming fundamentals through Ruby.

##What I Learned

At this point all of the students had dived into basic Ruby programming concepts in their pre-work labs to get into the program. 

- GitHUB Basics
- Variables (Data Types)
- Methods (Creating and Calling)
- Classes 
- Object Oriented Programming Concepts

##Challenges I Faced

**Information Overload:** The biggest challenge I had during the first week was learning to receive, digest and apply the large volumes of concepts we were learning. I sometimes felt when I could actually solve programming problems (through muscle memory), but had a hard time explaining why. This happened especially with object oriented programming concepts (specifically class and instance methods). 

##Learning Strategies

**Try To Explain It To Someone:** Understanding programming foundations is critical, especially since a lot of the tools and packages operate using those foundations. After the first week I met up with some of my peers over the weekend to talk through the OOP concepts we learned. It became incredibly clear where my weak points were as I tried talking it out. Every weekend I dedicate one day to reflecting on new concepts with my peers.

#Week 2: Ruby, SQL, and ActiveRecord (ORM)

Now that we had learned about objects and how they fit into applications, we learned that if you want your data to exist after your application is done running, you'll need a database. In order to create, read, update, and delete data in our databases, we dived into SQL and also made the connection between Ruby applications, SQL, and databases using an Object Relational Mapping Framework called ActiveRecord. Our code challenge happened this week (the passing the code challenge allows us to move to the next mod).

##Challenges I Faced

**Understanding Complex Relationships:** Learning SQL was miserable and awesome. For one, transitioning from Ruby's lexical-friendly syntax to SQL syntax was rough (no hate on SQL, really cool stuff). It was awesome to actually sort, find, and capture data from databases using SQL. It was even more mind blowing to take the Ruby classes and persist their data in databases, but it got **really complex** really quick, since we now had two languages (Ruby and SQL) interacting through a framework (ActiveRecord). 

##Learning Strategies

**Get Creative With Your Learning:** I learned that taking time to step back and package the large volumes of concepts into something visual that I could understand was essential in my "digestion" of the connections of the many pieces of complex programming elements. I started building visual "brain dumps" that helped me solidify my understanding of the ActiveRecord Framework and Ruby. It made some people laugh, and it was a huge help for me. Check it out [here](https://drive.google.com/file/d/1Uv677vjOGJPR2YT3g9a43f3cjfdaNFcG/preview)!

#Week 3: Tying it all together in a project

Now that we could connect Ruby classes, create relationships between them, and have them persist in databases using ActiveRecord, we had a few days to build a project (from scratch) that demonstrated our understanding of all of the concepts we'd learned over the past couple weeks. We were introduced to programming project building process elements like creating user stories and finding gems and other external resources and appropriating them into our project. This endeavor was incredibly challenging, but also involved some creativity! I decided to make a [small probability game](https://dev.to/shawnhuangfernandes/town-hall-brawl-my-first-cli-application-4ncc)!

##Challenges I Faced

**How To Scope A Project:** I didn't have a gauge of how much I could accomplish within a week. Coming from an engineering background, I naturally resorted to planning before I made any keystrokes. I constantly was catching myself adding "cool" features to the game (which I later learned were called "stretch goals"). The whiteboard I was planning on was getting pretty busy, and I didn't know what to remove, or what was essential, and it became a mess pretty quickly.

##What I Learned

**Lean On Others:** I know for a fact that if I spent my entire project working in a silo, my project would never have been anything close to what it was. During my planning process, I had my peers and coaches look over my plan. They set me straight quickly, and I pared down my action items to a reasonable amount. I also flushed out a step-by-step process for building out the program by consulting with others who had actually built projects. The most important thing is that I never realized how many awesome gems (packages) that other members in my class were using, and we all lifted each other up by sharing our insights and knowledge with each other.

#Week 4: Sinatra, Rack, and Rails

At this point of the course, we could create classes and relationships, persist data into a database, and do fun stuff locally on our machine. However, Flatiron's software engineering program turns students into web developers. Naturally, the next step would be to make our data onto a web page. Enter Sinatra. Sinatra is basically a minimalist collection of ruby methods and objects that allow our applications to interact with the web using the underlying **Rack** framework. This was a hard dive into a concept called "**Configuration vs. Convention**". Like ActiveRecord was a package of methods that we could call as long as we knew the syntax (**convention**) to deal with databases and objects, Sinatra presented an encapsulation of the hard work of some really talented developers to make tools we could call on to do some seriously heavy lifting in terms of setting up web connectivity (as long as you follow Sinatra's **convention**). We started with Sinatra to understand a methodology called MVC (Model, View, Controller) and begin structuring our programs (and understanding them) from that viewpoint. At the end of this week we then took our understanding of MVCs and applied it to Rails (or Ruby on Rails), which is a full stack (front-end, back-end) development tool for web applications. **This was a TON of information in one week**

##Challenges I Faced

**Maintaining a Flexible Learning Strategy:** Trying to balance understanding concepts in depth and keeping up with the labs and deliverables (as well as writing blog posts and preparing my resume and LinkedIn) got really hard as we started learning multiple web frameworks. I suddenly didn't have time make reference guides and it felt as if I was going through concepts blind, much like I was at the beginning of the program. I didn't really know any other way to learn.

##What I Learned

**One Size Does Not Fit All:** I had to adjust my learning strategy based on how overloaded my work was getting. In an ideal world I would have enough time to dive into the details of the details OF THE DETAILS of the things we were learning, but that wasn't realistic. When learning Sinatra, I had to focus on understanding the MVC conventions, but had to pass on the hard details of how to build a fully functioning project using Sinatra, because I knew we were moving onto Rails. When we hit Rails (which is such a huge framework) I had to make sure I understood why Rails Conventions were in place, but also couldn't fall into 'rabbit holes' like the underlying code that those conventions used. Being strategic about my learning helped prevent me from burning out, which was essential when our curriculum was really picking up.

#Week 5: Rails In Depth & Validations

This part of the course was really fun. We could create basic webpages using rails that could hold the classes (or models) we made. The webpages had basic CRUD (Create, Read, Update, Delete) functionality, which meant we could manipulate a database through our webpage. Super cool! We had started learning how to manually set up our Models, Views, and Controllers in Rails manually in the previous week, but that all changed. We started learning really powerful features of Rails that automated the web development process for a simple webpage so that we could automatically create our MVC structure. This meant we could focus on building the unique parts of our websites, rather than spending time laboring over setting up the website essentials. Rails provided all those essentials for us. We also learned how simple model validations worked, and learned why validation can prevent users from breaking or hacking into our websites. The culmination of all our knowledge was tested in a code challenge at the end of the week!

##Challenges I Faced

**Am I Interview Ready?** My previous learning strategies were serving me pretty well. I felt like I was understanding concepts pretty well, and I could explain it to others. One thing that entered my brain was **'Sure, I understand what I'm learning... but how would this serve me in terms of job acquisition?'**. I had this feeling that I could be doing more, and that in terms of being a future job applicant, I didn't really have much to show for? **Could I possibly tie my learning together with becoming a more appealing candidate for a future job?**

##What I learned

**Build Stuff - Learn and Look Awesome:** I absolutely loved my Mod 1 Project, and I really enjoyed showcasing it to anyone who was interested. More importantly, building my Mod 1 CLI project helped me develop my understanding of Ruby essentials. It made me realize that **building actual projects helps you become a better developer and demonstrates that you love coding to potential employers**. So I decided that I would try to build my very first project outside of the Flatiron curriculum! I'll post it here soon! It was meant to be very simple, but it really helped me learn and prepare for the code challenge while also making me feel like I was doing things directly beneficial for my career (and it was a blast!).

#Moving Forward From Here

The first 5 weeks of the program really stretched my brain, and I felt like I learned a ton of lessons from my peers, coaches, instructors, and the straight rigor of the material. I will be posting more about my experience in this bootcamp so that anybody who is interested or curious can glean some insight from it!

I will also try to post up other career related experiences as I go along:
- Meetups
- Hackathons
- Algorithm Practice
- Mini Projects
- General Insight

Thanks you so much for reading! Good luck in your own endeavors!

Shawn Huang Fernandes