Week 1 - Deploy on day one, Object Oriented programming, and getting to know each other!

A little dive into the Software Engineer Immersive Program at Flatiron School

I just started the Software Engineer Immersive Program at Flatiron School to become a Developer. I’ve been teaching myself how to code for more than a year using online resources such as FreeCodeCamp, Udemy, articles, books… but I got stuck at some point. I needed help! That’s why I decided to join Flatiron. This series of article is meant for people who are interested in doing a coding Bootcamp and wonder what the heck are we doing in here. It’s also a sort of a weekly journal for curious people, and let’s be honest, for me tracking my own journey!

Deploy on day one!

That was really cool to be put on a real work situation on day one. Our lead instructor went: “Often, on your first day of work, the team will ask you to deploy something, even if it’s something very small, so you are now part of the team. That’s what we are going to do today on your first day of school.”

Boom.

The assignment was to create a student profile for someone sitting at your table. So after some nice chatting to get to know one another, we started the project. We had to manipulate some HTML and practice git workflow. So here we go on GitHub, forking, cloning, committing, pushing, branching, and, eventually, merging!

When I usually use GitHub it’s only on my own repositories. Collaborating was a different experience that I really enjoyed! I was set for the week!

Be buried in work on day 2, 3, 4 and…5

The rest of the week was basically A LOT of material to dig through. The learning process is basically that we have many labs to complete, and between these labs, we have lectures on a specific subject, and so on. Oh yes, a really cool thing also, is that we all communicate through Slack (students, instructors, community lead etc). So instructors would send us group tasks — at least once a day — where we pair with someone else and complete a small project together.

We barely took breaks during this week. We were so overwhelmed by all these new concepts, labs, and group tasks. We couldn’t have been more immersed than that!

So what did we learned? The basics concept of Object Oriented in Ruby: classes, instance methods, object properties, object architecture, metaprogramming, object relationships.

What we mostly worked on is the Has Many relationships and Has Many Through relationships. It was really cool to think about a real-world situation and to translate it into code. For example, we would think of a startup, a venture capitalist, and of funding rounds. How are they connected to one another? How do they interact? Are they all directly connected? So here we could say that a startup has many venture capitalists through funding rounds; a venture capitalist has many startups through funding rounds, and so a funding round belongs to a startup and to a venture capitalist. It is what links the startup and the venture capitalist. From there we would create three classes: the Startupclass, the VentureCapitalistclass, and a third class, the joiner, or the source of truth, the FundingRounds class. Within each of these class, we are then able to create instance methods and class methods so we can actually DO something with our data and express real-world scenarios.

It looks something like this:

class Startup   
  attr_accessor :name, :domain  
  attr_reader :founder   
  @@all = []   
  def initialize(name, founder, domain)    
    @name = name    
    @founder = founder    
    @domain = domain     
    @@all << self  
  end  
  def self.all    
    @@all  
  end
end
class VentureCapitalist   
   attr_accessor :name, :total_worth   
     
   @@all = []   
     
   def initialize(name, total_worth)    
     @name = name    
     @total_worth = total_worth     
     @@all << self  
   end
def self.all    
     @@all  
   end 
end
class FundingRound
attr_reader :startup, :venture_capitalist, :type, :investment   
  @@all = []   
  def initialize(startup, venture_capitalist, type, investment) 
      
    @startup = startup    
    @venture_capitalist = venture_capitalist    
    @type = type    
    @investment = investment > 0 ? investment : 0     
    @@all << self   
  end
def self.all    
    @@all  
  end   
end

It’s not really a technical post; more an overview of what we learned this first week. The entire code can be found on my repo here.

#IceBreakers

I found Flatiron really good at creating a feeling of community straight away. Every day we had an icebreaker, a game where we would get to know each other through questions, little investigations etc.

I will mention one particular game because the morality of it resonated a lot on me and I think on each of us. In a room, we were all walking in no particular direction. Every time we would find someone in front of use, we would play paper/rock/scissors. We all start as eggs. Then if we win, we become a chicken. Then a triceratops. Once we lose, we have to support the person we lost against. Eventually, at the end of the game, there is only one winner, all the others cheering for him and encouraging him.

The morality of this is that every time we learn a new concept, we are at the egg stage. Then we become a little more comfortable and become chickens 🐓until we get to be a triceratops 🚀. But this never last. Very quickly in the process of learning how to code, we become an egg again. And again. And again. 🐣🐣🐣🐣🐣🐣🐣🐣🐣

This game reminds us also that we are in this all together, and that is super important to support each other. Because one week one of us may feel like a king, but the next week he’s going to feel crap. Nothing should be taken for granted, everything is yet to be learned. And every day is another day where we go to sleep knowing more than when we started. And that’s really great!!

I never thought I would feel so enriched after only 5 days in school. Looking forward to starting week 2!!

Cheers 🐝