Progress update #2
In my last update, I was just getting started on the path to becoming a software developer. I had recently quit my job and had only completed about half of the preparatory work required for entrance to the Launch School program. A month-and-a-half has gone by, and I’m happy to report that I’ve made a lot progress in that time!
There are 3 core tracks in the Launch School program that you must complete to fully graduate: Programming Foundations, Front-end Development and Frameworks & Integrations (considered capstone topics).
Programming Foundations consists of 5 different courses: Programming Foundations, Object Oriented Programming, Ruby Foundations: More Topics, Web Development and SQL/Relational Databases.
So far, I’ve completed Programming Foundations and am now close to completing Object Oriented Programming. In today’s update, I’ll mainly be talking about my experiences with those two courses.
101 Programming Foundations
This course took me about a month and a half to complete, including passing the assessments (which I’ll talk about a little later). Primarily, Programming Foundations is concerned with helping you gain fluency and muscle memory in general programming concepts. At a high level we covered:
- Strategies for breaking down larger problems into smaller, easier to manage/conceptualize components (ie. Psuedocode, flowcharts)
- Reading Ruby API documentation
- Commonly used data types (ie. String, Integer, Boolean)
- Basic data structures (ie. Arrays, Hashes)
- Collection manipulation(ie. Sorting, selection, transformation, iteration)
- Flow control
- Variable scope
- Debugging
- Ruby styling
In addition to the lectures and practice problems related to each of these topics, there were also a few larger projects we had to complete: a game of ‘Tic-Tac-Toe’ and simplified version of Blackjack called ‘21’. These two projects required us to implement all of the concepts we had learned throughout the course in a practical way.
If you’d like learn more about my experience writing the 21 program, or dig into my code, check out my earlier post:
In general, I felt confident progressing through the material and found the learning curve to be just right. At one point, however, I did get stuck while attempting to solve a particularly challenging exercise that involved the use of recursion.
If you’re a programmer, you know how frustrating it can be to encounter a concept or problem that you’re just not getting. Personally, I have a really hard time letting things like this go. I feel consumed by the problem at all hours of the day until I can solve it, or feel confident that I truly understand the concepts at work.
To move beyond this impasse, I did two things that really helped:
First, I got away from the computer. It’s amazing how much easier it can be to conceptualize and dissect a problem when you’re not staring directly at the code. You’d think it would be harder without being able to see all the details on the screen in front of you, but it’s not.
Second, in my time away from the problem, I reasoned that if I could identify and extract the traits common to all recursive functions, that might make it easier for me to understand how they work (or at the very least provide me with general guidance on how to write them until I did fully understand).
As a result, I not only improved my understanding of recursion, but I was able to come up with a framework for writing recursive functions that I believe can be applied in most cases where recursion is required. You can learn more about that here:
120 Object Oriented Programming
I’ve had some experience dabbling with programming prior to joining Launch School, so I was already fairly familiar with Object Oriented Programming (OOP). I believe it was then that the world of programming really clicked in my brain as something amazing.
All of a sudden I wasn’t just writing abstract code, I was creating real world (or fantastical) objects with their own behaviours and an ability to interact with the other objects around them. As a person with a big imagination and lots of ideas, this power to bring ideas to life in a meaningful way was intoxicating! Want to make a dragon that talks in 5 different languages, breathes fire on command and can also solve advanced mathematical problems? No problem! Simulate an entire planet’s ecosystem? You can do that too!
Anyway, inspiration aside, Launch School has of course taken my understanding of OOP to a much higher level already. The lessons covered in this course were primarily concerned with 3 of the key principles of OOP:
- Encapsulation
- Polymorphism
- Inheritance
These are all really deep topics on which volumes could be written, and have already been written, so I will not be writing at length on them here. However, if you’d like to learn more about these principles, I’d recommend Launch School’s free introduction book, Object Oriented Programming with Ruby. It’s a great place to get started on the subject.
I will, however, highlight one specific aspect of OOP that I found particularly interesting: ‘fake operators’.
You’re probably used to seeing operators in programming (ie. < = > == + / - etc.). In many languages (Java, for example) these operators are reserved by the language; their use has been specifically defined within the language itself and cannot be altered. In Ruby, however, many of these operators are actually just methods that can be overridden to perform in any way you like.
For example, let’s say you have an object that you’ve created from a custom class — we’ll say an Animal class — and you’d like to compare it against another Animal object to see if they share the same @species attribute.
Typically, if you were to use the == method to compare two custom objects, and you didn’t write your own == method for the object’s class, Ruby’s method look-up chain would eventually find and use the == method from the BasicObject class. This method compares objects based on their object_id. In other words, it determines if they are the exact same object in memory.
We want to compare based on the @species attribute and not theobject_id. To do this, we could simply add the method #==(other_object) to our Animal class like this:
class Animal
attr_reader :species def initialize(species)
@species = species
end def ==(other_object)
species == other_object.species
end
end
Now, when we compare two animal objects like this: animal1 == animal2 , the comparison will now be based on the objects’ @species attribute and not the objects’ location in memory. Neat!
Progression through mastery
I found all of these topics to be very enjoyable learn. And although they could be considered rather rudimentary by comparison to learning how to build a real-world application with a modern framework, I’ve found that intuitively knowing how to quickly and effectively implement code without struggling to remember syntax, has made it easier to think at the logical level.
What I really like about Launch School is that advancement through the program is based on comprehension of concepts; not some arbitrary timeline set to move students through the program material as fast as possible.
In a typical school (including many coding bootcamps), you progress through the course whether you’re absorbing the concepts or not. You’re on a schedule and there is very little account taken for students with different learning styles or speeds. In addition, the bar for ‘passing’ a course is typically very low, often between 50% and 70% (if there are any assessments at all). I believe a system like this limits a student’s potential.
At Launch School, time is not a factor. Comprehension is King and practice is Queen. As such, I’ve spent about half of my time so far working through practice problems; variations on the fundamental concepts, gradually increasing in difficulty and complexity. All of this to help you master the material and to prepare you for the next course.
Which brings me to assessments at Launch School.
In order to ‘complete’ a course and progress on to the next, you need to pass two assessments. The first is a timed, written assessment and the second is a live, technical interview. These assessments test multiple areas of competency, including: technical knowledge, your ability to articulate concepts (written and orally) and general professionalism. They are not easy, and even with all that practicing I referenced above, I still needed all 3 hours available to complete each of the written assessments.
Could I have gotten at least 70% of the answers correct without all of the extra practice? Maybe. But could I pass with 97% and 96% respectively as I did on both? Probably not. And that’s important, because at Launch School, anything less than 90% is not a guaranteed pass. In fact, score anything less than 100% and you’ll be required to correct your mistakes before progressing. No question left behind!
Does this make the program more challenging? Yes. But I now know all of the concepts referenced above like the back of my hand. This has made it easier to move on to learning more complex topics that demand a strong understanding of the fundamentals. And that, in turn, will make it easier to advance even further with a high degree of proficiency.
My recommendation is to avoid building up a ‘comprehension debt’ that you’ll have to pay for later. Go for mastery from the start.
Meetup with other programmers
Finally, I thought I’d mention that I’ve started to attend a local meet-up with other programmers in my area. My first impressions has been that attending meet-ups are great for a number of reasons:
- The sense of community is great for helping to keep up your motivation (especially if you’re working remotely and not attending classes physically).
- Sharing your code and having more experienced developers challenge your design choices or provide feedback in general is a great way to level-up your skills.
- Developing your professional network is a great way to get your name out there, because at some point, you’re probably going to want a programming job!
- Helping others who are new to software development is a great way to improve your own comprehension and retention of programming fundamentals.
And In my case, as it turns out, one of the regulars at our meet-up is personally connected with a couple of senior leaders at Basecamp, the company I most want to work for. He’s even offered to help facilitate an introduction when I’m ready. How cool is that?!
Well, that’s about all I’ve got for now. Next up I’ll be scheduling the technical interview for 120 Object Oriented Programming and then it’ll be on to some new subjects, including unit testing and working with closures/blocks. Should be interesting!
Until then, happy coding!
Enjoying my posts? If so, I’d be super grateful if you’d please give it a ‘clap’. And, if you’d like to be notified when I publish a new post, you can simply hit ‘follow’ at the top of the page. Thank you!
